From ed349a1043eddaf82526f53541c62e665fea339d Mon Sep 17 00:00:00 2001 From: Miles Macklin Date: Wed, 15 Feb 2023 11:34:32 +1300 Subject: [PATCH] Bump version to 0.7.2 --- CHANGELOG.md | 7 + VERSION.md | 3 +- .../html/_sources/modules/functions.rst.txt | 2584 ++++++++-------- docs/_build/html/genindex.html | 2 +- docs/_build/html/index.html | 2 +- docs/_build/html/modules/functions.html | 2600 ++++++++--------- docs/_build/html/modules/introduction.html | 2 +- docs/_build/html/modules/runtime.html | 2 +- docs/_build/html/modules/sim.html | 2 +- docs/_build/html/objects.inv | Bin 2809 -> 2809 bytes docs/_build/html/search.html | 2 +- docs/_build/html/searchindex.js | 2 +- docs/conf.py | 2 +- docs/modules/functions.rst | 2584 ++++++++-------- exts/omni.warp/config/extension.toml | 2 +- exts/omni.warp/docs/CHANGELOG.md | 7 + setup.py | 2 +- warp/config.py | 2 +- warp/stubs.py | 2346 +++++++-------- 19 files changed, 5084 insertions(+), 5069 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 85576b463..871846d01 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # CHANGELOG +## [0.7.2] - 2023-02-15 + +- Reduce test time for vec/math types +- Clean-up CUDA disabled build pipeline +- Remove extension.gen.toml to make Kit packages Python version independent +- Handle additional cases for array indexing inside Python + ## [0.7.1] - 2023-02-14 - Disabling some slow tests for Kit diff --git a/VERSION.md b/VERSION.md index 39e898a4f..9b289a3f0 100644 --- a/VERSION.md +++ b/VERSION.md @@ -1 +1,2 @@ -0.7.1 +0.7.2 + diff --git a/docs/_build/html/_sources/modules/functions.rst.txt b/docs/_build/html/_sources/modules/functions.rst.txt index 42d8e999c..d80aed0f0 100644 --- a/docs/_build/html/_sources/modules/functions.rst.txt +++ b/docs/_build/html/_sources/modules/functions.rst.txt @@ -68,12 +68,12 @@ Vector Types Scalar Math --------------- -.. function:: min(x: int32, y: int32) -> int32 +.. function:: min(x: uint32, y: uint32) -> uint32 Return the minimum of two scalars. -.. function:: min(x: int8, y: int8) -> int8 +.. function:: min(x: int16, y: int16) -> int16 Return the minimum of two scalars. @@ -83,42 +83,42 @@ Scalar Math Return the minimum of two scalars. -.. function:: min(x: int16, y: int16) -> int16 +.. function:: min(x: int8, y: int8) -> int8 Return the minimum of two scalars. -.. function:: min(x: uint32, y: uint32) -> uint32 +.. function:: min(x: float16, y: float16) -> float16 Return the minimum of two scalars. -.. function:: min(x: float16, y: float16) -> float16 +.. function:: min(x: uint16, y: uint16) -> uint16 Return the minimum of two scalars. -.. function:: min(x: uint64, y: uint64) -> uint64 +.. function:: min(x: int32, y: int32) -> int32 Return the minimum of two scalars. -.. function:: min(x: uint16, y: uint16) -> uint16 +.. function:: min(x: uint64, y: uint64) -> uint64 Return the minimum of two scalars. -.. function:: min(x: int64, y: int64) -> int64 +.. function:: min(x: float32, y: float32) -> float32 Return the minimum of two scalars. -.. function:: min(x: uint8, y: uint8) -> uint8 +.. function:: min(x: int64, y: int64) -> int64 Return the minimum of two scalars. -.. function:: min(x: float32, y: float32) -> float32 +.. function:: min(x: uint8, y: uint8) -> uint8 Return the minimum of two scalars. @@ -128,122 +128,122 @@ Scalar Math Return the minimum of two scalars. -.. function:: min(x: vec2h, y: vec2h) -> vec2h +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3h, y: vec3h) -> vec3h +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4h, y: vec4h) -> vec4h +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2d, y: vec2d) -> vec2d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3d, y: vec3d) -> vec3d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4d, y: vec4d) -> vec4d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2f, y: vec2f) -> vec2f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2f, y: vec2) -> vec2f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2, y: vec2f) -> vec2f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2, y: vec2) -> vec2f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3f, y: vec3f) -> vec3f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3f, y: vec3) -> vec3f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3, y: vec3f) -> vec3f +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3, y: vec3) -> vec3f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4f, y: vec4f) -> vec4f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4f, y: vec4) -> vec4f +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4, y: vec4f) -> vec4f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4, y: vec4) -> vec4f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vector_t, y: vector_t) -> vector_t +.. function:: min(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Return the element wise minimum of two vectors. -.. function:: max(x: int32, y: int32) -> int32 +.. function:: max(x: uint32, y: uint32) -> uint32 Return the maximum of two scalars. -.. function:: max(x: int8, y: int8) -> int8 +.. function:: max(x: int16, y: int16) -> int16 Return the maximum of two scalars. @@ -253,42 +253,42 @@ Scalar Math Return the maximum of two scalars. -.. function:: max(x: int16, y: int16) -> int16 +.. function:: max(x: int8, y: int8) -> int8 Return the maximum of two scalars. -.. function:: max(x: uint32, y: uint32) -> uint32 +.. function:: max(x: float16, y: float16) -> float16 Return the maximum of two scalars. -.. function:: max(x: float16, y: float16) -> float16 +.. function:: max(x: uint16, y: uint16) -> uint16 Return the maximum of two scalars. -.. function:: max(x: uint64, y: uint64) -> uint64 +.. function:: max(x: int32, y: int32) -> int32 Return the maximum of two scalars. -.. function:: max(x: uint16, y: uint16) -> uint16 +.. function:: max(x: uint64, y: uint64) -> uint64 Return the maximum of two scalars. -.. function:: max(x: int64, y: int64) -> int64 +.. function:: max(x: float32, y: float32) -> float32 Return the maximum of two scalars. -.. function:: max(x: uint8, y: uint8) -> uint8 +.. function:: max(x: int64, y: int64) -> int64 Return the maximum of two scalars. -.. function:: max(x: float32, y: float32) -> float32 +.. function:: max(x: uint8, y: uint8) -> uint8 Return the maximum of two scalars. @@ -298,122 +298,122 @@ Scalar Math Return the maximum of two scalars. -.. function:: max(x: vec2h, y: vec2h) -> vec2h +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3h, y: vec3h) -> vec3h +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4h, y: vec4h) -> vec4h +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2d, y: vec2d) -> vec2d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3d, y: vec3d) -> vec3d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4d, y: vec4d) -> vec4d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2f, y: vec2f) -> vec2f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2f, y: vec2) -> vec2f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2, y: vec2f) -> vec2f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2, y: vec2) -> vec2f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3f, y: vec3f) -> vec3f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3f, y: vec3) -> vec3f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3, y: vec3f) -> vec3f +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3, y: vec3) -> vec3f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4f, y: vec4f) -> vec4f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4f, y: vec4) -> vec4f +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4, y: vec4f) -> vec4f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4, y: vec4) -> vec4f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vector_t, y: vector_t) -> vector_t +.. function:: max(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Return the element wise maximum of two vectors. -.. function:: clamp(x: int32, a: int32, b: int32) -> int32 +.. function:: clamp(x: uint32, a: uint32, b: uint32) -> uint32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int8, a: int8, b: int8) -> int8 +.. function:: clamp(x: int16, a: int16, b: int16) -> int16 Clamp the value of x to the range [a, b]. @@ -423,42 +423,42 @@ Scalar Math Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int16, a: int16, b: int16) -> int16 +.. function:: clamp(x: int8, a: int8, b: int8) -> int8 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint32, a: uint32, b: uint32) -> uint32 +.. function:: clamp(x: float16, a: float16, b: float16) -> float16 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: float16, a: float16, b: float16) -> float16 +.. function:: clamp(x: uint16, a: uint16, b: uint16) -> uint16 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint64, a: uint64, b: uint64) -> uint64 +.. function:: clamp(x: int32, a: int32, b: int32) -> int32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint16, a: uint16, b: uint16) -> uint16 +.. function:: clamp(x: uint64, a: uint64, b: uint64) -> uint64 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int64, a: int64, b: int64) -> int64 +.. function:: clamp(x: float32, a: float32, b: float32) -> float32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint8, a: uint8, b: uint8) -> uint8 +.. function:: clamp(x: int64, a: int64, b: int64) -> int64 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: float32, a: float32, b: float32) -> float32 +.. function:: clamp(x: uint8, a: uint8, b: uint8) -> uint8 Clamp the value of x to the range [a, b]. @@ -468,12 +468,12 @@ Scalar Math Clamp the value of x to the range [a, b]. -.. function:: abs(x: int32) -> int32 +.. function:: abs(x: uint32) -> uint32 Return the absolute value of x. -.. function:: abs(x: int8) -> int8 +.. function:: abs(x: int16) -> int16 Return the absolute value of x. @@ -483,42 +483,42 @@ Scalar Math Return the absolute value of x. -.. function:: abs(x: int16) -> int16 +.. function:: abs(x: int8) -> int8 Return the absolute value of x. -.. function:: abs(x: uint32) -> uint32 +.. function:: abs(x: float16) -> float16 Return the absolute value of x. -.. function:: abs(x: float16) -> float16 +.. function:: abs(x: uint16) -> uint16 Return the absolute value of x. -.. function:: abs(x: uint64) -> uint64 +.. function:: abs(x: int32) -> int32 Return the absolute value of x. -.. function:: abs(x: uint16) -> uint16 +.. function:: abs(x: uint64) -> uint64 Return the absolute value of x. -.. function:: abs(x: int64) -> int64 +.. function:: abs(x: float32) -> float32 Return the absolute value of x. -.. function:: abs(x: uint8) -> uint8 +.. function:: abs(x: int64) -> int64 Return the absolute value of x. -.. function:: abs(x: float32) -> float32 +.. function:: abs(x: uint8) -> uint8 Return the absolute value of x. @@ -528,12 +528,12 @@ Scalar Math Return the absolute value of x. -.. function:: sign(x: int32) -> int32 +.. function:: sign(x: uint32) -> uint32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int8) -> int8 +.. function:: sign(x: int16) -> int16 Return -1 if x < 0, return 1 otherwise. @@ -543,42 +543,42 @@ Scalar Math Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int16) -> int16 +.. function:: sign(x: int8) -> int8 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint32) -> uint32 +.. function:: sign(x: float16) -> float16 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: float16) -> float16 +.. function:: sign(x: uint16) -> uint16 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint64) -> uint64 +.. function:: sign(x: int32) -> int32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint16) -> uint16 +.. function:: sign(x: uint64) -> uint64 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int64) -> int64 +.. function:: sign(x: float32) -> float32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint8) -> uint8 +.. function:: sign(x: int64) -> int64 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: float32) -> float32 +.. function:: sign(x: uint8) -> uint8 Return -1 if x < 0, return 1 otherwise. @@ -588,12 +588,12 @@ Scalar Math Return -1 if x < 0, return 1 otherwise. -.. function:: step(x: int32) -> int32 +.. function:: step(x: uint32) -> uint32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int8) -> int8 +.. function:: step(x: int16) -> int16 Return 1.0 if x < 0.0, return 0.0 otherwise. @@ -603,42 +603,42 @@ Scalar Math Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int16) -> int16 +.. function:: step(x: int8) -> int8 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint32) -> uint32 +.. function:: step(x: float16) -> float16 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: float16) -> float16 +.. function:: step(x: uint16) -> uint16 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint64) -> uint64 +.. function:: step(x: int32) -> int32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint16) -> uint16 +.. function:: step(x: uint64) -> uint64 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int64) -> int64 +.. function:: step(x: float32) -> float32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint8) -> uint8 +.. function:: step(x: int64) -> int64 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: float32) -> float32 +.. function:: step(x: uint8) -> uint8 Return 1.0 if x < 0.0, return 0.0 otherwise. @@ -648,12 +648,12 @@ Scalar Math Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: nonzero(x: int32) -> int32 +.. function:: nonzero(x: uint32) -> uint32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int8) -> int8 +.. function:: nonzero(x: int16) -> int16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. @@ -663,42 +663,42 @@ Scalar Math Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int16) -> int16 +.. function:: nonzero(x: int8) -> int8 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint32) -> uint32 +.. function:: nonzero(x: float16) -> float16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: float16) -> float16 +.. function:: nonzero(x: uint16) -> uint16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint64) -> uint64 +.. function:: nonzero(x: int32) -> int32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint16) -> uint16 +.. function:: nonzero(x: uint64) -> uint64 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int64) -> int64 +.. function:: nonzero(x: float32) -> float32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint8) -> uint8 +.. function:: nonzero(x: int64) -> int64 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: float32) -> float32 +.. function:: nonzero(x: uint8) -> uint8 Return 1.0 if x is not equal to zero, return 0.0 otherwise. @@ -708,17 +708,17 @@ Scalar Math Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: sin(x: float16) -> float16 +.. function:: sin(x: float64) -> float64 Return the sine of x in radians. -.. function:: sin(x: float64) -> float64 +.. function:: sin(x: float32) -> float32 Return the sine of x in radians. -.. function:: sin(x: float32) -> float32 +.. function:: sin(x: float16) -> float16 Return the sine of x in radians. @@ -728,17 +728,17 @@ Scalar Math Return the sine of x in radians. -.. function:: cos(x: float16) -> float16 +.. function:: cos(x: float64) -> float64 Return the cosine of x in radians. -.. function:: cos(x: float64) -> float64 +.. function:: cos(x: float32) -> float32 Return the cosine of x in radians. -.. function:: cos(x: float32) -> float32 +.. function:: cos(x: float16) -> float16 Return the cosine of x in radians. @@ -748,17 +748,17 @@ Scalar Math Return the cosine of x in radians. -.. function:: acos(x: float16) -> float16 +.. function:: acos(x: float64) -> float64 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: acos(x: float64) -> float64 +.. function:: acos(x: float32) -> float32 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: acos(x: float32) -> float32 +.. function:: acos(x: float16) -> float16 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. @@ -768,17 +768,17 @@ Scalar Math Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float16) -> float16 +.. function:: asin(x: float64) -> float64 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float64) -> float64 +.. function:: asin(x: float32) -> float32 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float32) -> float32 +.. function:: asin(x: float16) -> float16 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. @@ -788,17 +788,17 @@ Scalar Math Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: sqrt(x: float16) -> float16 +.. function:: sqrt(x: float64) -> float64 Return the sqrt of x, where x is positive. -.. function:: sqrt(x: float64) -> float64 +.. function:: sqrt(x: float32) -> float32 Return the sqrt of x, where x is positive. -.. function:: sqrt(x: float32) -> float32 +.. function:: sqrt(x: float16) -> float16 Return the sqrt of x, where x is positive. @@ -808,17 +808,17 @@ Scalar Math Return the sqrt of x, where x is positive. -.. function:: tan(x: float16) -> float16 +.. function:: tan(x: float64) -> float64 Return tangent of x in radians. -.. function:: tan(x: float64) -> float64 +.. function:: tan(x: float32) -> float32 Return tangent of x in radians. -.. function:: tan(x: float32) -> float32 +.. function:: tan(x: float16) -> float16 Return tangent of x in radians. @@ -828,17 +828,17 @@ Scalar Math Return tangent of x in radians. -.. function:: atan(x: float16) -> float16 +.. function:: atan(x: float64) -> float64 Return arctan of x. -.. function:: atan(x: float64) -> float64 +.. function:: atan(x: float32) -> float32 Return arctan of x. -.. function:: atan(x: float32) -> float32 +.. function:: atan(x: float16) -> float16 Return arctan of x. @@ -848,17 +848,17 @@ Scalar Math Return arctan of x. -.. function:: atan2(y: float16, x: float16) -> float16 +.. function:: atan2(y: float64, x: float64) -> float64 Return atan2 of x. -.. function:: atan2(y: float64, x: float64) -> float64 +.. function:: atan2(y: float32, x: float32) -> float32 Return atan2 of x. -.. function:: atan2(y: float32, x: float32) -> float32 +.. function:: atan2(y: float16, x: float16) -> float16 Return atan2 of x. @@ -868,17 +868,17 @@ Scalar Math Return atan2 of x. -.. function:: sinh(x: float16) -> float16 +.. function:: sinh(x: float64) -> float64 Return the sinh of x. -.. function:: sinh(x: float64) -> float64 +.. function:: sinh(x: float32) -> float32 Return the sinh of x. -.. function:: sinh(x: float32) -> float32 +.. function:: sinh(x: float16) -> float16 Return the sinh of x. @@ -888,17 +888,17 @@ Scalar Math Return the sinh of x. -.. function:: cosh(x: float16) -> float16 +.. function:: cosh(x: float64) -> float64 Return the cosh of x. -.. function:: cosh(x: float64) -> float64 +.. function:: cosh(x: float32) -> float32 Return the cosh of x. -.. function:: cosh(x: float32) -> float32 +.. function:: cosh(x: float16) -> float16 Return the cosh of x. @@ -908,17 +908,17 @@ Scalar Math Return the cosh of x. -.. function:: tanh(x: float16) -> float16 +.. function:: tanh(x: float64) -> float64 Return the tanh of x. -.. function:: tanh(x: float64) -> float64 +.. function:: tanh(x: float32) -> float32 Return the tanh of x. -.. function:: tanh(x: float32) -> float32 +.. function:: tanh(x: float16) -> float16 Return the tanh of x. @@ -938,17 +938,17 @@ Scalar Math Convert degrees into radians. -.. function:: log(x: float16) -> float16 +.. function:: log(x: float64) -> float64 Return the natural log (base-e) of x, where x is positive. -.. function:: log(x: float64) -> float64 +.. function:: log(x: float32) -> float32 Return the natural log (base-e) of x, where x is positive. -.. function:: log(x: float32) -> float32 +.. function:: log(x: float16) -> float16 Return the natural log (base-e) of x, where x is positive. @@ -958,17 +958,17 @@ Scalar Math Return the natural log (base-e) of x, where x is positive. -.. function:: log2(x: float16) -> float16 +.. function:: log2(x: float64) -> float64 Return the natural log (base-2) of x, where x is positive. -.. function:: log2(x: float64) -> float64 +.. function:: log2(x: float32) -> float32 Return the natural log (base-2) of x, where x is positive. -.. function:: log2(x: float32) -> float32 +.. function:: log2(x: float16) -> float16 Return the natural log (base-2) of x, where x is positive. @@ -978,17 +978,17 @@ Scalar Math Return the natural log (base-2) of x, where x is positive. -.. function:: log10(x: float16) -> float16 +.. function:: log10(x: float64) -> float64 Return the natural log (base-10) of x, where x is positive. -.. function:: log10(x: float64) -> float64 +.. function:: log10(x: float32) -> float32 Return the natural log (base-10) of x, where x is positive. -.. function:: log10(x: float32) -> float32 +.. function:: log10(x: float16) -> float16 Return the natural log (base-10) of x, where x is positive. @@ -998,17 +998,17 @@ Scalar Math Return the natural log (base-10) of x, where x is positive. -.. function:: exp(x: float16) -> float16 +.. function:: exp(x: float64) -> float64 Return base-e exponential, e^x. -.. function:: exp(x: float64) -> float64 +.. function:: exp(x: float32) -> float32 Return base-e exponential, e^x. -.. function:: exp(x: float32) -> float32 +.. function:: exp(x: float16) -> float16 Return base-e exponential, e^x. @@ -1018,17 +1018,17 @@ Scalar Math Return base-e exponential, e^x. -.. function:: pow(x: float16, y: float16) -> float16 +.. function:: pow(x: float64, y: float64) -> float64 Return the result of x raised to power of y. -.. function:: pow(x: float64, y: float64) -> float64 +.. function:: pow(x: float32, y: float32) -> float32 Return the result of x raised to power of y. -.. function:: pow(x: float32, y: float32) -> float32 +.. function:: pow(x: float16, y: float16) -> float16 Return the result of x raised to power of y. @@ -1038,21 +1038,21 @@ Scalar Math Return the result of x raised to power of y. -.. function:: round(x: float16) -> float16 +.. function:: round(x: float64) -> float64 Calculate the nearest integer value, 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()``. -.. function:: round(x: float64) -> float64 +.. function:: round(x: float32) -> float32 Calculate the nearest integer value, 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()``. -.. function:: round(x: float32) -> float32 +.. function:: round(x: float16) -> float16 Calculate the nearest integer value, 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()``. @@ -1066,21 +1066,21 @@ This is the most intuitive form of rounding in the colloquial sense, but can be Differs from ``numpy.round()``, which behaves the same way as ``numpy.rint()``. -.. function:: rint(x: float16) -> float16 +.. function:: rint(x: float64) -> float64 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: rint(x: float64) -> float64 +.. function:: rint(x: float32) -> float32 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: rint(x: float32) -> float32 +.. function:: rint(x: float16) -> float16 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. @@ -1094,7 +1094,7 @@ It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: trunc(x: float16) -> float16 +.. function:: trunc(x: float64) -> float64 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1102,7 +1102,7 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: trunc(x: float64) -> float64 +.. function:: trunc(x: float32) -> float32 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1110,7 +1110,7 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: trunc(x: float32) -> float32 +.. function:: trunc(x: float16) -> float16 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1126,17 +1126,17 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: floor(x: float16) -> float16 +.. function:: floor(x: float64) -> float64 Calculate the largest integer that is less than or equal to x. -.. function:: floor(x: float64) -> float64 +.. function:: floor(x: float32) -> float32 Calculate the largest integer that is less than or equal to x. -.. function:: floor(x: float32) -> float32 +.. function:: floor(x: float16) -> float16 Calculate the largest integer that is less than or equal to x. @@ -1146,17 +1146,17 @@ Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. Calculate the largest integer that is less than or equal to x. -.. function:: ceil(x: float16) -> float16 +.. function:: ceil(x: float64) -> float64 Calculate the smallest integer that is greater than or equal to x. -.. function:: ceil(x: float64) -> float64 +.. function:: ceil(x: float32) -> float32 Calculate the smallest integer that is greater than or equal to x. -.. function:: ceil(x: float32) -> float32 +.. function:: ceil(x: float16) -> float16 Calculate the smallest integer that is greater than or equal to x. @@ -1170,1741 +1170,1741 @@ Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. Vector Math --------------- -.. function:: dot(x: vec2h, y: vec2h) -> float16 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec3h, y: vec3h) -> float16 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec4h, y: vec4h) -> float16 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec2d, y: vec2d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3d, y: vec3d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec4d, y: vec4d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2ub, y: vec2ub) -> uint8 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3ub, y: vec3ub) -> uint8 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec4ub, y: vec4ub) -> uint8 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2f, y: vec2f) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2f, y: vec2) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2, y: vec2f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2, y: vec2) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3f, y: vec3f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3f, y: vec3) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3, y: vec3f) -> float32 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec3, y: vec3) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec4f, y: vec4f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec4f, y: vec4) -> float32 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vec4, y: vec4f) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vec4, y: vec4) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vector_t, y: vector_t) -> Scalar +.. function:: dot(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> Scalar Compute the dot product between two vectors. -.. function:: dot(x: quath, y: quath) -> float16 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float64 Compute the dot product between two quaternions. -.. function:: dot(x: quatd, y: quatd) -> float64 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quatf, y: quatf) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quatf, y: quat) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quat, y: quatf) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quat, y: quat) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float16 Compute the dot product between two quaternions. -.. function:: dot(x: vector_t, y: vector_t) -> Scalar +.. function:: dot(x: quaternion[~Float], y: quaternion[~Float]) -> Scalar Compute the dot product between two quaternions. -.. function:: ddot(x: mat22h, y: mat22h) -> float16 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33h, y: mat33h) -> float16 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44h, y: mat44h) -> float16 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22d, y: mat22d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33d, y: mat33d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44d, y: mat44d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22f, y: mat22f) -> float32 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22f, y: mat22) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22, y: mat22f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22, y: mat22) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33f, y: mat33f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33f, y: mat33) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33, y: mat33f) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33, y: mat33) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44f, y: mat44f) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44f, y: mat44) -> float32 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44, y: mat44f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44, y: mat44) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: matrix_t, y: matrix_t) -> Scalar +.. function:: ddot(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Compute the double dot product between two matrices. -.. function:: outer(x: vec2h, y: vec2h) -> mat22h +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3h, y: vec3h) -> mat33h +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4h, y: vec4h) -> mat44h +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2d, y: vec2d) -> mat22d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3d, y: vec3d) -> mat33d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4d, y: vec4d) -> mat44d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2f, y: vec2f) -> mat22f +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2f, y: vec2) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2, y: vec2f) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2, y: vec2) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3f, y: vec3f) -> mat33f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3f, y: vec3) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3, y: vec3f) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3, y: vec3) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4f, y: vec4f) -> mat44f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4f, y: vec4) -> mat44f +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4, y: vec4f) -> mat44f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4, y: vec4) -> mat44f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vector_t, y: vector_t) -> matrix_t +.. function:: outer(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: spatial_vectorh, y: spatial_vectorh) -> spatial_matrixh +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectord, y: spatial_vectord) -> spatial_matrixd +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectorf, y: spatial_vectorf) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectorf, y: spatial_vector) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vector, y: spatial_vectorf) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vector, y: spatial_vector) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: vector_t, y: vector_t) -> matrix_t +.. function:: outer(x: spatial_vector_t[~Float], y: spatial_vector_t[~Float]) -> spatial_matrix_t[~Float] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: cross(x: vec3h, y: vec3h) -> vec3h +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3d, y: vec3d) -> vec3d +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3f, y: vec3f) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3f, y: vec3) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3, y: vec3f) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3, y: vec3) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vector_t, y: vector_t) -> vector_t +.. function:: cross(x: vec[3, ~Scalar], y: vec[3, ~Scalar]) -> vec[3, ~Scalar] Compute the cross product of two 3d vectors. -.. function:: skew(x: vec3h) -> mat33h +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3d) -> mat33d +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3f) -> mat33f +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3) -> mat33f +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vector_t) +.. function:: skew(x: vec[3, ~Scalar]) Compute the skew symmetric matrix for a 3d vector. -.. function:: length(x: vec2h) -> float16 +.. function:: length(x: vec[2, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec3h) -> float16 +.. function:: length(x: vec[3, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec4h) -> float16 +.. function:: length(x: vec[4, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec2d) -> float64 +.. function:: length(x: vec[2, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3d) -> float64 +.. function:: length(x: vec[2, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec4d) -> float64 +.. function:: length(x: vec[3, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec2f) -> float32 +.. function:: length(x: vec[3, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec2) -> float32 +.. function:: length(x: vec[4, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3f) -> float32 +.. function:: length(x: vec[4, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3) -> float32 +.. function:: length(x: vec[2, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vec4f) -> float32 +.. function:: length(x: vec[3, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vec4) -> float32 +.. function:: length(x: vec[4, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vector_t) -> Scalar +.. function:: length(x: vec[typing.Any, ~Float]) -> Scalar Compute the length of a vector. -.. function:: length(x: quath) -> float16 +.. function:: length(x: quaternion[]) -> float64 Compute the length of a quaternion. -.. function:: length(x: quatd) -> float64 +.. function:: length(x: quaternion[]) -> float32 Compute the length of a quaternion. -.. function:: length(x: quatf) -> float32 +.. function:: length(x: quaternion[]) -> float32 Compute the length of a quaternion. -.. function:: length(x: quat) -> float32 +.. function:: length(x: quaternion[]) -> float16 Compute the length of a quaternion. -.. function:: length(x: vector_t) -> Scalar +.. function:: length(x: quaternion[~Float]) -> Scalar Compute the length of a quaternion. -.. function:: length_sq(x: vec2h) -> float16 +.. function:: length_sq(x: vec[2, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3h) -> float16 +.. function:: length_sq(x: vec[3, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4h) -> float16 +.. function:: length_sq(x: vec[4, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2d) -> float64 +.. function:: length_sq(x: vec[2, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3d) -> float64 +.. function:: length_sq(x: vec[2, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4d) -> float64 +.. function:: length_sq(x: vec[3, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2ub) -> uint8 +.. function:: length_sq(x: vec[3, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3ub) -> uint8 +.. function:: length_sq(x: vec[4, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4ub) -> uint8 +.. function:: length_sq(x: vec[4, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2f) -> float32 +.. function:: length_sq(x: vec[2, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2) -> float32 +.. function:: length_sq(x: vec[3, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3f) -> float32 +.. function:: length_sq(x: vec[4, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3) -> float32 +.. function:: length_sq(x: vec[2, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4f) -> float32 +.. function:: length_sq(x: vec[3, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4) -> float32 +.. function:: length_sq(x: vec[4, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vector_t) -> Scalar +.. function:: length_sq(x: vec[typing.Any, ~Scalar]) -> Scalar Compute the squared length of a 2d vector. -.. function:: length_sq(x: quath) -> float16 +.. function:: length_sq(x: quaternion[]) -> float64 Compute the squared length of a quaternion. -.. function:: length_sq(x: quatd) -> float64 +.. function:: length_sq(x: quaternion[]) -> float32 Compute the squared length of a quaternion. -.. function:: length_sq(x: quatf) -> float32 +.. function:: length_sq(x: quaternion[]) -> float32 Compute the squared length of a quaternion. -.. function:: length_sq(x: quat) -> float32 +.. function:: length_sq(x: quaternion[]) -> float16 Compute the squared length of a quaternion. -.. function:: length_sq(x: vector_t) -> Scalar +.. function:: length_sq(x: quaternion[~Scalar]) -> Scalar Compute the squared length of a quaternion. -.. function:: normalize(x: vec2h) -> vec2h +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3h) -> vec3h +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4h) -> vec4h +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2d) -> vec2d +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3d) -> vec3d +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4d) -> vec4d +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2f) -> vec2f +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2) -> vec2f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3f) -> vec3f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3) -> vec3f +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4f) -> vec4f +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4) -> vec4f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vector_t) -> vector_t +.. function:: normalize(x: vec[typing.Any, ~Float]) -> vec[typing.Any, ~Scalar] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: quath) -> quath +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quatd) -> quatd +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quatf) -> quatf +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quat) -> quatf +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: vector_t) -> vector_t +.. function:: normalize(x: quaternion[~Float]) -> quaternion[~Scalar] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: transpose(m: mat22h) -> mat22h +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33h) -> mat33h +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44h) -> mat44h +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22d) -> mat22d +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33d) -> mat33d +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44d) -> mat44d +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22f) -> mat22f +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22) -> mat22f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33f) -> mat33f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33) -> mat33f +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44f) -> mat44f +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44) -> mat44f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: matrix_t) +.. function:: transpose(m: mat[typing.Any, typing.Any, ~Scalar]) Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixh) -> spatial_matrixh +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixd) -> spatial_matrixd +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixf) -> spatial_matrixf +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrix) -> spatial_matrixf +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: matrix_t) -> matrix_t +.. function:: transpose(m: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] Return the transpose of the matrix m -.. function:: inverse(m: mat22h) -> mat22h +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33h) -> mat33h +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44h) -> mat44h +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22d) -> mat22d +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33d) -> mat33d +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44d) -> mat44d +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22f) -> mat22f +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22) -> mat22f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33f) -> mat33f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33) -> mat33f +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44f) -> mat44f +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44) -> mat44f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: matrix_t) -> matrix_t +.. function:: inverse(m: mat[typing.Any, typing.Any, ~Float]) -> mat[typing.Any, typing.Any, ~Float] Return the inverse of the matrix m -.. function:: determinant(m: mat22h) -> float16 +.. function:: determinant(m: mat[2, 2, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat33h) -> float16 +.. function:: determinant(m: mat[3, 3, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat44h) -> float16 +.. function:: determinant(m: mat[4, 4, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat22d) -> float64 +.. function:: determinant(m: mat[2, 2, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33d) -> float64 +.. function:: determinant(m: mat[2, 2, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat44d) -> float64 +.. function:: determinant(m: mat[3, 3, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat22f) -> float32 +.. function:: determinant(m: mat[3, 3, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat22) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33f) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33) -> float32 +.. function:: determinant(m: mat[2, 2, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: mat44f) -> float32 +.. function:: determinant(m: mat[3, 3, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: mat44) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: matrix_t) -> Scalar +.. function:: determinant(m: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Return the determinant of the matrix m -.. function:: trace(m: mat22h) -> float16 +.. function:: trace(m: mat[2, 2, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat33h) -> float16 +.. function:: trace(m: mat[3, 3, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat44h) -> float16 +.. function:: trace(m: mat[4, 4, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat22d) -> float64 +.. function:: trace(m: mat[2, 2, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33d) -> float64 +.. function:: trace(m: mat[2, 2, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat44d) -> float64 +.. function:: trace(m: mat[3, 3, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat22f) -> float32 +.. function:: trace(m: mat[3, 3, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat22) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33f) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33) -> float32 +.. function:: trace(m: mat[2, 2, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: mat44f) -> float32 +.. function:: trace(m: mat[3, 3, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: mat44) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: matrix_t) -> Scalar +.. function:: trace(m: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Return the trace of the matrix m -.. function:: diag(d: vec2h) -> mat22h +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3h) -> mat33h +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4h) -> mat44h +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2d) -> mat22d +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3d) -> mat33d +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4d) -> mat44d +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2f) -> mat22f +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2) -> mat22f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3f) -> mat33f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3) -> mat33f +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4f) -> mat44f +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4) -> mat44f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vector_t) +.. function:: diag(d: vec[typing.Any, ~Scalar]) Returns a matrix with the components of the vector d on the diagonal -.. function:: cw_mul(x: vec2h, y: vec2h) -> vec2h +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3h, y: vec3h) -> vec3h +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4h, y: vec4h) -> vec4h +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2d, y: vec2d) -> vec2d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3d, y: vec3d) -> vec3d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4d, y: vec4d) -> vec4d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2f, y: vec2f) -> vec2f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2f, y: vec2) -> vec2f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2, y: vec2f) -> vec2f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2, y: vec2) -> vec2f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3f, y: vec3f) -> vec3f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3f, y: vec3) -> vec3f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3, y: vec3f) -> vec3f +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3, y: vec3) -> vec3f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4f, y: vec4f) -> vec4f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4f, y: vec4) -> vec4f +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4, y: vec4f) -> vec4f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4, y: vec4) -> vec4f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vector_t, y: vector_t) -> vector_t +.. function:: cw_mul(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22h, y: mat22h) -> mat22h +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33h, y: mat33h) -> mat33h +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44h, y: mat44h) -> mat44h +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22d, y: mat22d) -> mat22d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33d, y: mat33d) -> mat33d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44d, y: mat44d) -> mat44d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22f, y: mat22f) -> mat22f +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22f, y: mat22) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22, y: mat22f) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22, y: mat22) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33f, y: mat33f) -> mat33f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33f, y: mat33) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33, y: mat33f) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33, y: mat33) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44f, y: mat44f) -> mat44f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44f, y: mat44) -> mat44f +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44, y: mat44f) -> mat44f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44, y: mat44) -> mat44f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: cw_mul(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Component wise multiply of two 2d vectors. -.. function:: cw_div(x: vec2h, y: vec2h) -> vec2h +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3h, y: vec3h) -> vec3h +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4h, y: vec4h) -> vec4h +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2d, y: vec2d) -> vec2d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3d, y: vec3d) -> vec3d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4d, y: vec4d) -> vec4d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2f, y: vec2f) -> vec2f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2f, y: vec2) -> vec2f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2, y: vec2f) -> vec2f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2, y: vec2) -> vec2f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3f, y: vec3f) -> vec3f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3f, y: vec3) -> vec3f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3, y: vec3f) -> vec3f +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3, y: vec3) -> vec3f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4f, y: vec4f) -> vec4f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4f, y: vec4) -> vec4f +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4, y: vec4f) -> vec4f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4, y: vec4) -> vec4f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vector_t, y: vector_t) -> vector_t +.. function:: cw_div(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22h, y: mat22h) -> mat22h +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33h, y: mat33h) -> mat33h +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44h, y: mat44h) -> mat44h +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22d, y: mat22d) -> mat22d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33d, y: mat33d) -> mat33d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44d, y: mat44d) -> mat44d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22f, y: mat22f) -> mat22f +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22f, y: mat22) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22, y: mat22f) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22, y: mat22) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33f, y: mat33f) -> mat33f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33f, y: mat33) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33, y: mat33f) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33, y: mat33) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44f, y: mat44f) -> mat44f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44f, y: mat44) -> mat44f +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44, y: mat44f) -> mat44f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44, y: mat44) -> mat44f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: cw_div(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Component wise division of two 2d vectors. -.. function:: vec() -> vector_t +.. function:: vec() -> vec[typing.Any, ~Scalar] Construct a zero-initialized vector. -.. function:: vec(s: Scalar) -> vector_t +.. function:: vec(s: Scalar) -> vec[typing.Any, ~Scalar] Construct a vector with all components set to s. -.. function:: vec() -> vector_t +.. function:: vec() -> vec[typing.Any, ~Scalar] Construct a vector from scalar compontents. -.. function:: mat() -> matrix_t +.. function:: mat() -> mat[typing.Any, typing.Any, ~Scalar] Construct a zero matrix -.. function:: mat(s: Scalar) -> matrix_t +.. function:: mat(s: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] Construct a matrix with all components set to s -.. function:: mat(pos: vector_t, rot: vector_t, scale: vector_t) -> matrix_t +.. function:: mat(pos: vec[3, ~Float], rot: quaternion[~Float], scale: vec[3, ~Float]) -> mat[typing.Any, typing.Any, ~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 -.. function:: mat() -> matrix_t +.. function:: mat() -> mat[typing.Any, typing.Any, ~Scalar] Construct a matrix from components or column vectors. -.. function:: svd3(A: mat33h, U: mat33h, sigma: vec3h, V: mat33h) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33d, U: mat33d, sigma: vec3d, V: mat33d) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: matrix_t, U: matrix_t, sigma: vector_t, V: matrix_t) -> None +.. function:: svd3(A: mat[3, 3, ~Float], U: mat[3, 3, ~Float], sigma: vec[3, ~Float], V: mat[3, 3, ~Scalar]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: qr3(A: mat33h, Q: mat33h, R: mat33h) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33d, Q: mat33d, R: mat33d) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33f, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33f, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33f, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33f, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: matrix_t, Q: matrix_t, R: matrix_t) -> None +.. function:: qr3(A: mat[3, 3, ~Float], Q: mat[3, 3, ~Float], R: mat[3, 3, ~Float]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: eig3(A: mat33h, Q: mat33h, d: vec3h) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33d, Q: mat33d, d: vec3d) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33f, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33f, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33f, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33f, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: matrix_t, Q: matrix_t, d: vector_t) -> None +.. function:: eig3(A: mat[3, 3, ~Float], Q: mat[3, 3, ~Float], d: vec[3, ~Float]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. @@ -2913,283 +2913,283 @@ Vector Math Quaternion Math --------------- -.. function:: quaternion() -> vector_t +.. function:: 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. -.. function:: quaternion(x: Float, y: Float, z: Float, w: Float) -> vector_t +.. function:: quaternion(x: Float, y: Float, z: Float, w: Float) -> quaternion[~Float] Construct a quarternion from its components x, y, z are the imaginary parts, w is the real part. -.. function:: quaternion(i: vector_t, r: Float) -> vector_t +.. function:: quaternion(i: vec[3, ~Float], r: Float) -> quaternion[~Float] Construct a quaternion from it's imaginary components i, and real part r -.. function:: quat_identity() -> quat +.. function:: quat_identity() -> quaternion[] Construct a float32 identity quaternion with zero imaginary part and real part of 1.0 -.. function:: quat_from_axis_angle(axis: vec3h, angle: float16) -> quath +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float64) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3d, angle: float64) -> quatd +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float16) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3f, angle: float32) -> quatf +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3, angle: float32) -> quatf +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vector_t, angle: Float) -> vector_t +.. function:: quat_from_axis_angle(axis: vec[3, ~Float], angle: Float) -> quaternion[~Scalar] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_to_axis_angle(q: quath, axis: vec3h, angle: float16) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float64) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatd, axis: vec3d, angle: float64) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatf, axis: vec3f, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatf, axis: vec3, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quat, axis: vec3f, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quat, axis: vec3, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float16) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: vector_t, axis: vector_t, angle: Float) -> None +.. function:: quat_to_axis_angle(q: quaternion[~Float], axis: vec[3, ~Float], angle: Float) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_from_matrix(m: mat33h) -> quath +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33d) -> quatd +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33f) -> quatf +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33) -> quatf +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: matrix_t) -> vector_t +.. function:: quat_from_matrix(m: mat[3, 3, ~Float]) -> quaternion[~Scalar] Construct a quaternion from a 3x3 matrix. -.. function:: quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quath +.. function:: quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quatd +.. function:: quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quatf +.. function:: quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: Float, pitch: Float, yaw: Float) -> vector_t +.. function:: 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. -.. function:: quat_inverse(q: quath) -> quath +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quatd) -> quatd +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quatf) -> quatf +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quat) -> quatf +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: vector_t) -> vector_t +.. function:: quat_inverse(q: quaternion[~Float]) -> quaternion[~Scalar] Compute quaternion conjugate. -.. function:: quat_rotate(q: quath, p: vec3h) -> vec3h +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatd, p: vec3d) -> vec3d +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatf, p: vec3f) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatf, p: vec3) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quat, p: vec3f) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quat, p: vec3) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: vector_t, p: vector_t) -> vector_t +.. function:: quat_rotate(q: quaternion[~Float], p: vec[3, ~Float]) -> vec[3, ~Scalar] Rotate a vector by a quaternion. -.. function:: quat_rotate_inv(q: quath, p: vec3h) -> vec3h +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatd, p: vec3d) -> vec3d +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatf, p: vec3f) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatf, p: vec3) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quat, p: vec3f) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quat, p: vec3) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: vector_t, p: vector_t) -> vector_t +.. function:: quat_rotate_inv(q: quaternion[~Float], p: vec[3, ~Float]) -> vec[3, ~Scalar] Rotate a vector the inverse of a quaternion. -.. function:: quat_slerp(q0: quath, q1: quath, t: float16) -> quath +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float64) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatd, q1: quatd, t: float64) -> quatd +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float16) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatf, q1: quatf, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatf, q1: quat, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quat, q1: quatf, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quat, q1: quat, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: vector_t, q1: vector_t, t: Float) -> vector_t +.. function:: quat_slerp(q0: quaternion[~Float], q1: quaternion[~Float], t: Float) -> quaternion[~Scalar] Linearly interpolate between two quaternions. -.. function:: quat_to_matrix(q: quath) -> mat33h +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quatd) -> mat33d +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quatf) -> mat33f +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quat) -> mat33f +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: vector_t) -> matrix_t +.. function:: quat_to_matrix(q: quaternion[~Float]) -> mat[3, 3, ~Scalar] Convert a quaternion to a 3x3 rotation matrix. @@ -3198,290 +3198,290 @@ Quaternion Math Transformations --------------- -.. function:: transform_t(p: vector_t, q: vector_t) -> transform_class +.. function:: transform_t(p: vec[3, ~Float], q: quaternion[~Float]) -> transform_t[~Scalar] Construct a rigid body transformation with translation part p and rotation q. -.. function:: transform_identity() -> transform +.. function:: transform_identity() -> transform_t[] Construct a float32 identity transform with zero translation and identity rotation. -.. function:: transform_get_translation(t: transformh) -> vec3h +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transformd) -> vec3d +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transformf) -> vec3f +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transform) -> vec3f +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transform_class) -> vector_t +.. function:: transform_get_translation(t: transform_t[~Float]) -> vec[3, ~Scalar] Return the translational part of a transform. -.. function:: transform_get_rotation(t: transformh) -> quath +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transformd) -> quatd +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transformf) -> quatf +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transform) -> quatf +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transform_class) -> vector_t +.. function:: transform_get_rotation(t: transform_t[~Float]) -> quaternion[~Scalar] Return the rotational part of a transform. -.. function:: transform_multiply(a: transformh, b: transformh) -> transformh +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformd, b: transformd) -> transformd +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformf, b: transformf) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformf, b: transform) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform, b: transformf) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform, b: transform) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform_class, b: transform_class) -> transform_class +.. function:: transform_multiply(a: transform_t[~Float], b: transform_t[~Float]) -> transform_t[~Scalar] Multiply two rigid body transformations together. -.. function:: transform_point(t: transformh, p: vec3h) -> vec3h +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformd, p: vec3d) -> vec3d +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformf, p: vec3f) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformf, p: vec3) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform, p: vec3f) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform, p: vec3) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform_class, p: vector_t) -> vector_t +.. function:: transform_point(t: transform_t[~Scalar], p: vec[3, ~Scalar]) -> vec[3, ~Scalar] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(m: mat44h, p: vec3h) -> vec3h +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44d, p: vec3d) -> vec3d +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44f, p: vec3f) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44f, p: vec3) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44, p: vec3f) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44, p: vec3) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: matrix_t, p: vector_t) -> vector_t +.. function:: transform_point(m: mat[4, 4, ~Scalar], p: vec[3, ~Scalar]) -> vec[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 tranformation matrix before calling this method. -.. function:: transform_vector(t: transformh, v: vec3h) -> vec3h +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformd, v: vec3d) -> vec3d +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformf, v: vec3f) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformf, v: vec3) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform, v: vec3f) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform, v: vec3) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform_class, v: vector_t) -> vector_t +.. function:: transform_vector(t: transform_t[~Scalar], v: vec[3, ~Scalar]) -> vec[3, ~Scalar] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(m: mat44h, v: vec3h) -> vec3h +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44d, v: vec3d) -> vec3d +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44f, v: vec3f) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44f, v: vec3) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44, v: vec3f) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44, v: vec3) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: matrix_t, v: vector_t) -> vector_t +.. function:: transform_vector(m: mat[4, 4, ~Scalar], v: vec[3, ~Scalar]) -> vec[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 tranformation matrix before calling this method. -.. function:: transform_inverse(t: transformh) -> transformh +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transformd) -> transformd +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transformf) -> transformf +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transform) -> transformf +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transform_class) -> transform_class +.. function:: transform_inverse(t: transform_t[~Float]) -> transform_t[~Float] Compute the inverse of the transform. @@ -3490,200 +3490,200 @@ Transformations Spatial Math --------------- -.. function:: spatial_vector_t() -> vector_t +.. function:: spatial_vector_t() -> spatial_vector_t[~Float] Construct a zero-initialized 6d screw vector. Screw vectors may be used to represent rigid body wrenches and twists (velocites). -.. function:: spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) -> vector_t +.. function:: spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) -> spatial_vector_t[~Float] Construct a 6d screw vector from it's components. -.. function:: spatial_vector_t(w: vector_t, v: vector_t) -> vector_t +.. function:: spatial_vector_t(w: vec[3, ~Float], v: vec[3, ~Float]) -> spatial_vector_t[~Float] Construct a 6d screw vector from two 3d vectors. -.. function:: spatial_vector_t(s: Float) -> vector_t +.. function:: spatial_vector_t(s: Float) -> spatial_vector_t[~Float] Construct a 6d screw vector with all components set to s -.. function:: spatial_matrix_t() -> matrix_t +.. function:: spatial_matrix_t() -> spatial_matrix_t[~Float] Construct a 6x6 zero-initialized spatial inertia matrix -.. function:: spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) -> matrix_t +.. function:: spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) -> spatial_matrix_t[~Float] Construct a 6x6 spatial inertia matrix from components -.. function:: spatial_adjoint(r: matrix_t, s: matrix_t) -> matrix_t +.. function:: spatial_adjoint(r: mat[3, 3, ~Float], s: mat[3, 3, ~Float]) -> spatial_matrix_t[~Scalar] Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks. -.. function:: spatial_dot(a: spatial_vectorh, b: spatial_vectorh) -> float16 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float64 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectord, b: spatial_vectord) -> float64 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectorf, b: spatial_vectorf) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectorf, b: spatial_vector) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vector, b: spatial_vectorf) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vector, b: spatial_vector) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float16 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: vector_t, b: vector_t) -> Scalar +.. function:: spatial_dot(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> Scalar Compute the dot product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vector, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: vector_t, b: vector_t) -> vector_t +.. function:: spatial_cross(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> spatial_vector_t[~Float] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vector, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: vector_t, b: vector_t) -> vector_t +.. function:: spatial_cross_dual(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> spatial_vector_t[~Float] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_top(a: spatial_vectorh) -> vec3h +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vectord) -> vec3d +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vectorf) -> vec3f +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vector) -> vec3f +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: vector_t) +.. function:: spatial_top(a: spatial_vector_t[~Float]) Return the top (first) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectorh) -> vec3h +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectord) -> vec3d +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectorf) -> vec3f +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vector) -> vec3f +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: vector_t) +.. function:: spatial_bottom(a: spatial_vector_t[~Float]) Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_jacobian(S: array[vector_t], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]) -> None +.. function:: spatial_jacobian(S: array[spatial_vector_t[~Float]], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]) -> None -.. function:: spatial_mass(I_s: array[matrix_t], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) -> None +.. function:: spatial_mass(I_s: array[spatial_matrix_t[~Float]], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) -> None @@ -3875,467 +3875,467 @@ Utility Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quath, arg2: quath) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quatf, arg2: quatf) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quatd, arg2: quatd) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quat, arg2: quat) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformh, arg2: transformh) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformf, arg2: transformf) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformd, arg2: transformd) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transform, arg2: transform) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2h, arg2: vec2h) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3h, arg2: vec3h) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4h, arg2: vec4h) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2d, arg2: vec2d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3d, arg2: vec3d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4d, arg2: vec4d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2ub, arg2: vec2ub) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3ub, arg2: vec3ub) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4ub, arg2: vec4ub) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2f, arg2: vec2f) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2f, arg2: vec2) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2, arg2: vec2f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2, arg2: vec2) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3f, arg2: vec3f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3f, arg2: vec3) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3, arg2: vec3f) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3, arg2: vec3) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4f, arg2: vec4f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4f, arg2: vec4) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4, arg2: vec4f) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4, arg2: vec4) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vector_t, arg2: vector_t) +.. function:: expect_eq(arg1: vec[typing.Any, ~Scalar], arg2: vec[typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22h, arg2: mat22h) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33h, arg2: mat33h) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44h, arg2: mat44h) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22d, arg2: mat22d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33d, arg2: mat33d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44d, arg2: mat44d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22f, arg2: mat22f) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22f, arg2: mat22) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22, arg2: mat22f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22, arg2: mat22) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33f, arg2: mat33f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33f, arg2: mat33) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33, arg2: mat33f) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33, arg2: mat33) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44f, arg2: mat44f) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44f, arg2: mat44) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44, arg2: mat44f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44, arg2: mat44) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: matrix_t, arg2: matrix_t) +.. function:: expect_eq(arg1: mat[typing.Any, typing.Any, ~Scalar], arg2: mat[typing.Any, typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_neq(arg1: vec2h, arg2: vec2h) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3h, arg2: vec3h) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4h, arg2: vec4h) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2d, arg2: vec2d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3d, arg2: vec3d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4d, arg2: vec4d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2ub, arg2: vec2ub) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3ub, arg2: vec3ub) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4ub, arg2: vec4ub) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2f, arg2: vec2f) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2f, arg2: vec2) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2, arg2: vec2f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2, arg2: vec2) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3f, arg2: vec3f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3f, arg2: vec3) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3, arg2: vec3f) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3, arg2: vec3) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4f, arg2: vec4f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4f, arg2: vec4) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4, arg2: vec4f) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4, arg2: vec4) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vector_t, arg2: vector_t) +.. function:: expect_neq(arg1: vec[typing.Any, ~Scalar], arg2: vec[typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22h, arg2: mat22h) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33h, arg2: mat33h) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44h, arg2: mat44h) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22d, arg2: mat22d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33d, arg2: mat33d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44d, arg2: mat44d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22f, arg2: mat22f) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22f, arg2: mat22) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22, arg2: mat22f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22, arg2: mat22) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33f, arg2: mat33f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33f, arg2: mat33) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33, arg2: mat33f) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33, arg2: mat33) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44f, arg2: mat44f) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44f, arg2: mat44) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44, arg2: mat44f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44, arg2: mat44) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: matrix_t, arg2: matrix_t) +.. function:: expect_neq(arg1: mat[typing.Any, typing.Any, ~Scalar], arg2: mat[typing.Any, typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are equal -.. function:: lerp(a: float16, b: float16, t: float16) -> float16 +.. function:: lerp(a: float64, b: float64, t: float64) -> float64 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: float64, b: float64, t: float64) -> float64 +.. function:: lerp(a: float32, b: float32, t: float32) -> float32 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: float32, b: float32, t: float32) -> float32 +.. function:: lerp(a: float16, b: float16, t: float16) -> float16 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` @@ -4345,217 +4345,217 @@ Utility Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2h, b: vec2h, t: float16) -> vec2h +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float16) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2f, b: vec2f, t: float32) -> vec2f +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2d, b: vec2d, t: float64) -> vec2d +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float64) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2, b: vec2, t: float32) -> vec2 +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3h, b: vec3h, t: float16) -> vec3h +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float16) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3f, b: vec3f, t: float32) -> vec3f +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3d, b: vec3d, t: float64) -> vec3d +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float64) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3, b: vec3, t: float32) -> vec3 +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4h, b: vec4h, t: float16) -> vec4h +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float16) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4f, b: vec4f, t: float32) -> vec4f +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4d, b: vec4d, t: float64) -> vec4d +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float64) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4, b: vec4, t: float32) -> vec4 +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22h, b: mat22h, t: float16) -> mat22h +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float16) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22f, b: mat22f, t: float32) -> mat22f +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22d, b: mat22d, t: float64) -> mat22d +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float64) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22, b: mat22, t: float32) -> mat22 +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33h, b: mat33h, t: float16) -> mat33h +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float16) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33f, b: mat33f, t: float32) -> mat33f +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33d, b: mat33d, t: float64) -> mat33d +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float64) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33, b: mat33, t: float32) -> mat33 +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44h, b: mat44h, t: float16) -> mat44h +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float16) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44f, b: mat44f, t: float32) -> mat44f +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44d, b: mat44d, t: float64) -> mat44d +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float64) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44, b: mat44, t: float32) -> mat44 +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quath, b: quath, t: float16) -> quath +.. function:: lerp(a: quaternion[], b: quaternion[], t: float16) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quatf, b: quatf, t: float32) -> quatf +.. function:: lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quatd, b: quatd, t: float64) -> quatd +.. function:: lerp(a: quaternion[], b: quaternion[], t: float64) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quat, b: quat, t: float32) -> quat +.. function:: lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformh, b: transformh, t: float16) -> transformh +.. function:: lerp(a: transform_t[], b: transform_t[], t: float16) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformf, b: transformf, t: float32) -> transformf +.. function:: lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformd, b: transformd, t: float64) -> transformd +.. function:: lerp(a: transform_t[], b: transform_t[], t: float64) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transform, b: transform, t: float32) -> transform +.. function:: lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectorh, b: spatial_vectorh, t: float16) -> spatial_vectorh +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float16) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectorf, b: spatial_vectorf, t: float32) -> spatial_vectorf +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectord, b: spatial_vectord, t: float64) -> spatial_vectord +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float64) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vector, b: spatial_vector, t: float32) -> spatial_vector +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixh, b: spatial_matrixh, t: float16) -> spatial_matrixh +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float16) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixf, b: spatial_matrixf, t: float32) -> spatial_matrixf +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixd, b: spatial_matrixd, t: float64) -> spatial_matrixd +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float64) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrix, b: spatial_matrix, t: float32) -> spatial_matrix +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: smoothstep(edge0: float16, edge1: float16, x: float16) -> float16 +.. function:: smoothstep(edge0: float64, edge1: float64, x: float64) -> float64 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 -.. function:: smoothstep(edge0: float64, edge1: float64, x: float64) -> float64 +.. function:: smoothstep(edge0: float32, edge1: float32, x: float32) -> float32 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 -.. function:: smoothstep(edge0: float32, edge1: float32, x: float32) -> float32 +.. function:: smoothstep(edge0: float16, edge1: float16, x: float16) -> float16 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 @@ -4565,17 +4565,17 @@ Utility 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 -.. function:: expect_near(arg1: float16, arg2: float16, tolerance: float16) -> None +.. function:: expect_near(arg1: float64, arg2: float64, tolerance: float64) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: float64, arg2: float64, tolerance: float64) -> None +.. function:: expect_near(arg1: float32, arg2: float32, tolerance: float32) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: float32, arg2: float32, tolerance: float32) -> None +.. function:: expect_near(arg1: float16, arg2: float16, tolerance: float16) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude @@ -4585,7 +4585,7 @@ Utility Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: vec3, arg2: vec3, tolerance: float32) -> None +.. function:: expect_near(arg1: vec[3, ], arg2: vec[3, ], tolerance: float32) -> None Prints an error to stdout if any element of arg1 and arg2 are not closer than tolerance in magnitude @@ -4594,7 +4594,7 @@ Utility Geometry --------------- -.. function:: bvh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> bvh_query_t +.. function:: bvh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4604,7 +4604,7 @@ Geometry :param upper: The upper bound of the bounding box in bvh space -.. function:: bvh_query_ray(id: uint64, start: vec3, dir: vec3) -> bvh_query_t +.. function:: bvh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4620,7 +4620,7 @@ Geometry if there are no more overlapping bound. -.. function:: mesh_query_point(id: uint64, point: vec3, max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool +.. function:: mesh_query_point(id: uint64, point: vec[3, ], max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool Computes the closest point on the mesh with identifier `id` to the given point in space. Returns ``True`` if a point < ``max_dist`` is found. @@ -4633,7 +4633,7 @@ Geometry :param bary_v: Retruns the barycentric v coordinate of the closest point -.. function:: mesh_query_ray(id: uint64, start: vec3, dir: vec3, max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec3, face: int32) -> bool +.. function:: mesh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ], max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec[3, ], face: int32) -> bool Computes the closest ray hit on the mesh with identifier `id`, returns ``True`` if a point < ``max_t`` is found. @@ -4649,7 +4649,7 @@ Geometry :param face: Returns the index of the hit face -.. function:: mesh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> mesh_query_aabb_t +.. function:: mesh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> mesh_query_aabb_t Construct an axis-aligned bounding box query against a mesh object. This query can be used to iterate over all triangles inside a volume. Returns an object that is used to track state during mesh traversal. @@ -4665,17 +4665,17 @@ Geometry if there are no more overlapping triangles. -.. function:: mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3 +.. function:: mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ] Evaluates the position on the mesh given a face index, and barycentric coordinates. -.. function:: mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3 +.. function:: mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ] Evaluates the velocity on the mesh given a face index, and barycentric coordinates. -.. function:: hash_grid_query(id: uint64, point: vec3, max_dist: float32) -> hash_grid_query_t +.. function:: hash_grid_query(id: uint64, point: vec[3, ], max_dist: float32) -> hash_grid_query_t Construct a point query against a hash grid. This query can be used to iterate over all neighboring points withing a fixed radius from the query point. Returns an object that is used to track state during neighbor traversal. @@ -4693,7 +4693,7 @@ Geometry traversal occurs in a spatially coherent order. -.. function:: intersect_tri_tri(v0: vec3, v1: vec3, v2: vec3, u0: vec3, u1: vec3, u2: vec3) -> int +.. function:: intersect_tri_tri(v0: vec[3, ], v1: vec[3, ], v2: vec[3, ], u0: vec[3, ], u1: vec[3, ], u2: vec[3, ]) -> int Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method. Returns > 0 if triangles intersect. @@ -4703,17 +4703,17 @@ Geometry Retrieves the mesh given its index. -.. function:: mesh_eval_face_normal(id: uint64, face: int32) -> vec3 +.. function:: mesh_eval_face_normal(id: uint64, face: int32) -> vec[3, ] Evaluates the face normal the mesh given a face index. -.. function:: mesh_get_point(id: uint64, index: int32) -> vec3 +.. function:: mesh_get_point(id: uint64, index: int32) -> vec[3, ] Returns the point of the mesh given a index. -.. function:: mesh_get_velocity(id: uint64, index: int32) -> vec3 +.. function:: mesh_get_velocity(id: uint64, index: int32) -> vec[3, ] Returns the velocity of the mesh given a index. @@ -4723,7 +4723,7 @@ Geometry Returns the point-index of the mesh given a face-vertex index. -.. function:: closest_point_edge_edge(p1: vec3, q1: vec3, p2: vec3, q2: vec3, epsilon: float32) -> vec3 +.. function:: closest_point_edge_edge(p1: vec[3, ], q1: vec[3, ], p2: vec[3, ], q2: vec[3, ], epsilon: float32) -> vec[3, ] 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. @@ -4739,7 +4739,7 @@ Geometry Volumes --------------- -.. function:: volume_sample_f(id: uint64, uvw: vec3, sampling_mode: int32) -> float +.. function:: volume_sample_f(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> float Sample the volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` @@ -4754,22 +4754,22 @@ Volumes Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_sample_v(id: uint64, uvw: vec3, sampling_mode: int32) -> vec3 +.. function:: volume_sample_v(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> vec[3, ] Sample the vector volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` -.. function:: volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec3 +.. function:: volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec[3, ] 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 -.. function:: volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3) -> None +.. function:: volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec[3, ]) -> None Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_sample_i(id: uint64, uvw: vec3) -> int +.. function:: volume_sample_i(id: uint64, uvw: vec[3, ]) -> int Sample the int32 volume given by ``id`` at the volume local-space point ``uvw``. @@ -4784,22 +4784,22 @@ Volumes Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_index_to_world(id: uint64, uvw: vec3) -> vec3 +.. function:: volume_index_to_world(id: uint64, uvw: vec[3, ]) -> vec[3, ] Transform a point defined in volume index space to world space given the volume's intrinsic affine transformation. -.. function:: volume_world_to_index(id: uint64, xyz: vec3) -> vec3 +.. function:: volume_world_to_index(id: uint64, xyz: vec[3, ]) -> vec[3, ] Transform a point defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. -.. function:: volume_index_to_world_dir(id: uint64, uvw: vec3) -> vec3 +.. function:: volume_index_to_world_dir(id: uint64, uvw: vec[3, ]) -> vec[3, ] Transform a direction defined in volume index space to world space given the volume's intrinsic affine transformation. -.. function:: volume_world_to_index_dir(id: uint64, xyz: vec3) -> vec3 +.. function:: volume_world_to_index_dir(id: uint64, xyz: vec[3, ]) -> vec[3, ] Transform a direction defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. @@ -4850,47 +4850,47 @@ Random Inverse transform sample a cumulative distribution function -.. function:: sample_triangle(state: uint32) -> vec2 +.. function:: sample_triangle(state: uint32) -> vec[2, ] Uniformly sample a triangle. Returns sample barycentric coordinates -.. function:: sample_unit_ring(state: uint32) -> vec2 +.. function:: sample_unit_ring(state: uint32) -> vec[2, ] Uniformly sample a ring in the xy plane -.. function:: sample_unit_disk(state: uint32) -> vec2 +.. function:: sample_unit_disk(state: uint32) -> vec[2, ] Uniformly sample a disk in the xy plane -.. function:: sample_unit_sphere_surface(state: uint32) -> vec3 +.. function:: sample_unit_sphere_surface(state: uint32) -> vec[3, ] Uniformly sample a unit sphere surface -.. function:: sample_unit_sphere(state: uint32) -> vec3 +.. function:: sample_unit_sphere(state: uint32) -> vec[3, ] Uniformly sample a unit sphere -.. function:: sample_unit_hemisphere_surface(state: uint32) -> vec3 +.. function:: sample_unit_hemisphere_surface(state: uint32) -> vec[3, ] Uniformly sample a unit hemisphere surface -.. function:: sample_unit_hemisphere(state: uint32) -> vec3 +.. function:: sample_unit_hemisphere(state: uint32) -> vec[3, ] Uniformly sample a unit hemisphere -.. function:: sample_unit_square(state: uint32) -> vec2 +.. function:: sample_unit_square(state: uint32) -> vec[2, ] Uniformly sample a unit square -.. function:: sample_unit_cube(state: uint32) -> vec3 +.. function:: sample_unit_cube(state: uint32) -> vec[3, ] Uniformly sample a unit cube @@ -4900,17 +4900,17 @@ Random Non-periodic Perlin-style noise in 1d. -.. function:: noise(state: uint32, xy: vec2) -> float +.. function:: noise(state: uint32, xy: vec[2, ]) -> float Non-periodic Perlin-style noise in 2d. -.. function:: noise(state: uint32, xyz: vec3) -> float +.. function:: noise(state: uint32, xyz: vec[3, ]) -> float Non-periodic Perlin-style noise in 3d. -.. function:: noise(state: uint32, xyzt: vec4) -> float +.. function:: noise(state: uint32, xyzt: vec[4, ]) -> float Non-periodic Perlin-style noise in 4d. @@ -4920,32 +4920,32 @@ Random Periodic Perlin-style noise in 1d. -.. function:: pnoise(state: uint32, xy: vec2, px: int32, py: int32) -> float +.. function:: pnoise(state: uint32, xy: vec[2, ], px: int32, py: int32) -> float Periodic Perlin-style noise in 2d. -.. function:: pnoise(state: uint32, xyz: vec3, px: int32, py: int32, pz: int32) -> float +.. function:: pnoise(state: uint32, xyz: vec[3, ], px: int32, py: int32, pz: int32) -> float Periodic Perlin-style noise in 3d. -.. function:: pnoise(state: uint32, xyzt: vec4, px: int32, py: int32, pz: int32, pt: int32) -> float +.. function:: pnoise(state: uint32, xyzt: vec[4, ], px: int32, py: int32, pz: int32, pt: int32) -> float Periodic Perlin-style noise in 4d. -.. function:: curlnoise(state: uint32, xy: vec2) -> vec2 +.. function:: curlnoise(state: uint32, xy: vec[2, ]) -> vec[2, ] Divergence-free vector field based on the gradient of a Perlin noise function. [1]_ -.. function:: curlnoise(state: uint32, xyz: vec3) -> vec3 +.. function:: curlnoise(state: uint32, xyz: vec[3, ]) -> vec[3, ] Divergence-free vector field based on the curl of three Perlin noise functions. [1]_ -.. function:: curlnoise(state: uint32, xyzt: vec4) -> vec3 +.. function:: curlnoise(state: uint32, xyzt: vec[4, ]) -> vec[3, ] Divergence-free vector field based on the curl of three Perlin noise functions. [1]_ @@ -4954,12 +4954,12 @@ Random Other --------------- -.. function:: lower_bound(arr: array[Scalar], value: int32) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int8) -> int +.. function:: lower_bound(arr: array[Scalar], value: int16) -> int Search a sorted array for the closest element greater than or equal to value. @@ -4969,42 +4969,42 @@ Other Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int16) -> int +.. function:: lower_bound(arr: array[Scalar], value: int8) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint32) -> int +.. function:: lower_bound(arr: array[Scalar], value: float16) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: float16) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint16) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint64) -> int +.. function:: lower_bound(arr: array[Scalar], value: int32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint16) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint64) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int64) -> int +.. function:: lower_bound(arr: array[Scalar], value: float32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint8) -> int +.. function:: lower_bound(arr: array[Scalar], value: int64) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: float32) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint8) -> int Search a sorted array for the closest element greater than or equal to value. @@ -5018,28 +5018,31 @@ Other Operators --------------- -.. function:: add(x: int32, y: int32) -> int32 +.. function:: add(x: uint32, y: uint32) -> uint32 -.. function:: add(x: int8, y: int8) -> int8 +.. function:: add(x: int16, y: int16) -> int16 .. function:: add(x: float64, y: float64) -> float64 -.. function:: add(x: int16, y: int16) -> int16 +.. function:: add(x: int8, y: int8) -> int8 -.. function:: add(x: uint32, y: uint32) -> uint32 +.. function:: add(x: float16, y: float16) -> float16 -.. function:: add(x: float16, y: float16) -> float16 +.. function:: add(x: uint16, y: uint16) -> uint16 + + +.. function:: add(x: int32, y: int32) -> int32 .. function:: add(x: uint64, y: uint64) -> uint64 -.. function:: add(x: uint16, y: uint16) -> uint16 +.. function:: add(x: float32, y: float32) -> float32 .. function:: add(x: int64, y: int64) -> int64 @@ -5048,241 +5051,241 @@ Operators .. function:: add(x: uint8, y: uint8) -> uint8 -.. function:: add(x: float32, y: float32) -> float32 - - .. function:: add(x: Scalar, y: Scalar) -> Scalar -.. function:: add(x: vec2h, y: vec2h) -> vec2h +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3h, y: vec3h) -> vec3h +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4h, y: vec4h) -> vec4h +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec2d, y: vec2d) -> vec2d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3d, y: vec3d) -> vec3d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec4d, y: vec4d) -> vec4d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2f, y: vec2f) -> vec2f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2f, y: vec2) -> vec2f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2, y: vec2f) -> vec2f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec2, y: vec2) -> vec2f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3f, y: vec3f) -> vec3f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3f, y: vec3) -> vec3f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3, y: vec3f) -> vec3f +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3, y: vec3) -> vec3f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4f, y: vec4f) -> vec4f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec4f, y: vec4) -> vec4f +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec4, y: vec4f) -> vec4f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4, y: vec4) -> vec4f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: add(x: quath, y: quath) -> quath +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatd, y: quatd) -> quatd +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatf, y: quatf) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatf, y: quat) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quat, y: quatf) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quat, y: quat) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: add(x: mat22h, y: mat22h) -> mat22h +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat33h, y: mat33h) -> mat33h +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat44h, y: mat44h) -> mat44h +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat22d, y: mat22d) -> mat22d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat33d, y: mat33d) -> mat33d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat44d, y: mat44d) -> mat44d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat22f, y: mat22f) -> mat22f +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat22f, y: mat22) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat22, y: mat22f) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat22, y: mat22) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat33f, y: mat33f) -> mat33f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat33f, y: mat33) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat33, y: mat33f) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat33, y: mat33) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat44f, y: mat44f) -> mat44f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat44f, y: mat44) -> mat44f +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat44, y: mat44f) -> mat44f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat44, y: mat44) -> mat44f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: add(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: add(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vector, y: spatial_vector) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: spatial_vector_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: add(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: add(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: add(x: transformh, y: transformh) -> transformh +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformd, y: transformd) -> transformd +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformf, y: transformf) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformf, y: transform) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform, y: transformf) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform, y: transform) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform_class, y: transform_class) -> transform_class +.. function:: add(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: sub(x: int32, y: int32) -> int32 +.. function:: sub(x: uint32, y: uint32) -> uint32 -.. function:: sub(x: int8, y: int8) -> int8 +.. function:: sub(x: int16, y: int16) -> int16 .. function:: sub(x: float64, y: float64) -> float64 -.. function:: sub(x: int16, y: int16) -> int16 +.. function:: sub(x: int8, y: int8) -> int8 -.. function:: sub(x: uint32, y: uint32) -> uint32 +.. function:: sub(x: float16, y: float16) -> float16 -.. function:: sub(x: float16, y: float16) -> float16 +.. function:: sub(x: uint16, y: uint16) -> uint16 + + +.. function:: sub(x: int32, y: int32) -> int32 .. function:: sub(x: uint64, y: uint64) -> uint64 -.. function:: sub(x: uint16, y: uint16) -> uint16 +.. function:: sub(x: float32, y: float32) -> float32 .. function:: sub(x: int64, y: int64) -> int64 @@ -5291,241 +5294,241 @@ Operators .. function:: sub(x: uint8, y: uint8) -> uint8 -.. function:: sub(x: float32, y: float32) -> float32 - - .. function:: sub(x: Scalar, y: Scalar) -> Scalar -.. function:: sub(x: vec2h, y: vec2h) -> vec2h +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3h, y: vec3h) -> vec3h +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4h, y: vec4h) -> vec4h +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec2d, y: vec2d) -> vec2d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3d, y: vec3d) -> vec3d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec4d, y: vec4d) -> vec4d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2f, y: vec2f) -> vec2f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2f, y: vec2) -> vec2f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2, y: vec2f) -> vec2f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec2, y: vec2) -> vec2f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3f, y: vec3f) -> vec3f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3f, y: vec3) -> vec3f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3, y: vec3f) -> vec3f +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3, y: vec3) -> vec3f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4f, y: vec4f) -> vec4f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec4f, y: vec4) -> vec4f +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec4, y: vec4f) -> vec4f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4, y: vec4) -> vec4f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: sub(x: mat22h, y: mat22h) -> mat22h +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat33h, y: mat33h) -> mat33h +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat44h, y: mat44h) -> mat44h +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat22d, y: mat22d) -> mat22d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat33d, y: mat33d) -> mat33d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat44d, y: mat44d) -> mat44d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat22f, y: mat22f) -> mat22f +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat22f, y: mat22) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat22, y: mat22f) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat22, y: mat22) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat33f, y: mat33f) -> mat33f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat33f, y: mat33) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat33, y: mat33f) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat33, y: mat33) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat44f, y: mat44f) -> mat44f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat44f, y: mat44) -> mat44f +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat44, y: mat44f) -> mat44f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat44, y: mat44) -> mat44f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: sub(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: sub(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vector, y: spatial_vector) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: spatial_vector_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: sub(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: sub(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: sub(x: quath, y: quath) -> quath +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatd, y: quatd) -> quatd +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatf, y: quatf) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatf, y: quat) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quat, y: quatf) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quat, y: quat) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: sub(x: transformh, y: transformh) -> transformh +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformd, y: transformd) -> transformd +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformf, y: transformf) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformf, y: transform) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform, y: transformf) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform, y: transform) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform_class, y: transform_class) -> transform_class +.. function:: sub(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: int32, y: int32) -> int32 +.. function:: mul(x: uint32, y: uint32) -> uint32 -.. function:: mul(x: int8, y: int8) -> int8 +.. function:: mul(x: int16, y: int16) -> int16 .. function:: mul(x: float64, y: float64) -> float64 -.. function:: mul(x: int16, y: int16) -> int16 +.. function:: mul(x: int8, y: int8) -> int8 -.. function:: mul(x: uint32, y: uint32) -> uint32 +.. function:: mul(x: float16, y: float16) -> float16 -.. function:: mul(x: float16, y: float16) -> float16 +.. function:: mul(x: uint16, y: uint16) -> uint16 + + +.. function:: mul(x: int32, y: int32) -> int32 .. function:: mul(x: uint64, y: uint64) -> uint64 -.. function:: mul(x: uint16, y: uint16) -> uint16 +.. function:: mul(x: float32, y: float32) -> float32 .. function:: mul(x: int64, y: int64) -> int64 @@ -5534,526 +5537,526 @@ Operators .. function:: mul(x: uint8, y: uint8) -> uint8 -.. function:: mul(x: float32, y: float32) -> float32 - - .. function:: mul(x: Scalar, y: Scalar) -> Scalar -.. function:: mul(x: vec2h, y: float16) -> vec2h +.. function:: mul(x: vec[2, ], y: float64) -> vec[2, ] -.. function:: mul(x: vec3h, y: float16) -> vec3h +.. function:: mul(x: vec[3, ], y: float64) -> vec[3, ] -.. function:: mul(x: vec4h, y: float16) -> vec4h +.. function:: mul(x: vec[4, ], y: float64) -> vec[4, ] -.. function:: mul(x: vec2d, y: float64) -> vec2d +.. function:: mul(x: vec[2, ], y: float16) -> vec[2, ] -.. function:: mul(x: vec3d, y: float64) -> vec3d +.. function:: mul(x: vec[3, ], y: float16) -> vec[3, ] -.. function:: mul(x: vec4d, y: float64) -> vec4d +.. function:: mul(x: vec[4, ], y: float16) -> vec[4, ] -.. function:: mul(x: vec2ub, y: uint8) -> vec2ub +.. function:: mul(x: vec[2, ], y: uint8) -> vec[2, ] -.. function:: mul(x: vec3ub, y: uint8) -> vec3ub +.. function:: mul(x: vec[3, ], y: uint8) -> vec[3, ] -.. function:: mul(x: vec4ub, y: uint8) -> vec4ub +.. function:: mul(x: vec[4, ], y: uint8) -> vec[4, ] -.. function:: mul(x: vec2f, y: float32) -> vec2f +.. function:: mul(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: mul(x: vec2, y: float32) -> vec2f +.. function:: mul(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: mul(x: vec3f, y: float32) -> vec3f +.. function:: mul(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: mul(x: vec3, y: float32) -> vec3f +.. function:: mul(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: mul(x: vec4f, y: float32) -> vec4f +.. function:: mul(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: mul(x: vec4, y: float32) -> vec4f +.. function:: mul(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: vec[typing.Any, ~Scalar], y: Scalar) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: float16, y: vec2h) -> vec2h +.. function:: mul(x: float64, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float16, y: vec3h) -> vec3h +.. function:: mul(x: float64, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float16, y: vec4h) -> vec4h +.. function:: mul(x: float64, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float64, y: vec2d) -> vec2d +.. function:: mul(x: float16, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float64, y: vec3d) -> vec3d +.. function:: mul(x: float16, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float64, y: vec4d) -> vec4d +.. function:: mul(x: float16, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: uint8, y: vec2ub) -> vec2ub +.. function:: mul(x: uint8, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: uint8, y: vec3ub) -> vec3ub +.. function:: mul(x: uint8, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: uint8, y: vec4ub) -> vec4ub +.. function:: mul(x: uint8, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float32, y: vec2f) -> vec2f +.. function:: mul(x: float32, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float32, y: vec2) -> vec2f +.. function:: mul(x: float32, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float32, y: vec3f) -> vec3f +.. function:: mul(x: float32, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float32, y: vec3) -> vec3f +.. function:: mul(x: float32, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float32, y: vec4f) -> vec4f +.. function:: mul(x: float32, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float32, y: vec4) -> vec4f +.. function:: mul(x: float32, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: quath, y: float16) -> quath +.. function:: mul(x: quaternion[], y: float64) -> quaternion[] -.. function:: mul(x: quatd, y: float64) -> quatd +.. function:: mul(x: quaternion[], y: float16) -> quaternion[] -.. function:: mul(x: quatf, y: float32) -> quatf +.. function:: mul(x: quaternion[], y: float32) -> quaternion[] -.. function:: mul(x: quat, y: float32) -> quatf +.. function:: mul(x: quaternion[], y: float32) -> quaternion[] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: quaternion[~Scalar], y: Scalar) -> quaternion[~Scalar] -.. function:: mul(x: float16, y: quath) -> quath +.. function:: mul(x: float64, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float64, y: quatd) -> quatd +.. function:: mul(x: float16, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float32, y: quatf) -> quatf +.. function:: mul(x: float32, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float32, y: quat) -> quatf +.. function:: mul(x: float32, y: quaternion[]) -> quaternion[] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: mul(x: quath, y: quath) -> quath +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatd, y: quatd) -> quatd +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatf, y: quatf) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatf, y: quat) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quat, y: quatf) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quat, y: quat) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: vector_t, y: vector_t) -> vector_t +.. function:: mul(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: mul(x: float16, y: mat22h) -> mat22h +.. function:: mul(x: float64, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float16, y: mat33h) -> mat33h +.. function:: mul(x: float64, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float16, y: mat44h) -> mat44h +.. function:: mul(x: float64, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float64, y: mat22d) -> mat22d +.. function:: mul(x: float16, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float64, y: mat33d) -> mat33d +.. function:: mul(x: float16, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float64, y: mat44d) -> mat44d +.. function:: mul(x: float16, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float32, y: mat22f) -> mat22f +.. function:: mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float32, y: mat22) -> mat22f +.. function:: mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float32, y: mat33f) -> mat33f +.. function:: mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float32, y: mat33) -> mat33f +.. function:: mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float32, y: mat44f) -> mat44f +.. function:: mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float32, y: mat44) -> mat44f +.. function:: mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: Scalar, y: matrix_t) -> matrix_t +.. function:: mul(x: Scalar, y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: float16) -> mat22h +.. function:: mul(x: mat[2, 2, ], y: float64) -> mat[2, 2, ] -.. function:: mul(x: mat33h, y: float16) -> mat33h +.. function:: mul(x: mat[3, 3, ], y: float64) -> mat[3, 3, ] -.. function:: mul(x: mat44h, y: float16) -> mat44h +.. function:: mul(x: mat[4, 4, ], y: float64) -> mat[4, 4, ] -.. function:: mul(x: mat22d, y: float64) -> mat22d +.. function:: mul(x: mat[2, 2, ], y: float16) -> mat[2, 2, ] -.. function:: mul(x: mat33d, y: float64) -> mat33d +.. function:: mul(x: mat[3, 3, ], y: float16) -> mat[3, 3, ] -.. function:: mul(x: mat44d, y: float64) -> mat44d +.. function:: mul(x: mat[4, 4, ], y: float16) -> mat[4, 4, ] -.. function:: mul(x: mat22f, y: float32) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: mul(x: mat22, y: float32) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: mul(x: mat33f, y: float32) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: mul(x: mat33, y: float32) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: mul(x: mat44f, y: float32) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: mul(x: mat44, y: float32) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: mul(x: matrix_t, y: Scalar) -> matrix_t +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: vec2h) -> vec2h +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33h, y: vec3h) -> vec3h +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44h, y: vec4h) -> vec4h +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat22d, y: vec2d) -> vec2d +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33d, y: vec3d) -> vec3d +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44d, y: vec4d) -> vec4d +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat22f, y: vec2f) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22f, y: vec2) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22, y: vec2f) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22, y: vec2) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33f, y: vec3f) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33f, y: vec3) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33, y: vec3f) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33, y: vec3) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44f, y: vec4f) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44f, y: vec4) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44, y: vec4f) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44, y: vec4) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: matrix_t, y: vector_t) -> vector_t +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: mat22h) -> mat22h +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat33h, y: mat33h) -> mat33h +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat44h, y: mat44h) -> mat44h +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat22d, y: mat22d) -> mat22d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat33d, y: mat33d) -> mat33d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat44d, y: mat44d) -> mat44d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat22f, y: mat22f) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat22f, y: mat22) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat22, y: mat22f) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat22, y: mat22) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat33f, y: mat33f) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat33f, y: mat33) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat33, y: mat33f) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat33, y: mat33) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat44f, y: mat44f) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat44f, y: mat44) -> mat44f +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat44, y: mat44f) -> mat44f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat44, y: mat44) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: matrix_t, y: matrix_t) +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -.. function:: mul(x: spatial_vectorh, y: float16) -> spatial_vectorh +.. function:: mul(x: spatial_vector_t[], y: float64) -> spatial_vector_t[] -.. function:: mul(x: spatial_vectord, y: float64) -> spatial_vectord +.. function:: mul(x: spatial_vector_t[], y: float16) -> spatial_vector_t[] -.. function:: mul(x: spatial_vectorf, y: float32) -> spatial_vectorf +.. function:: mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[] -.. function:: mul(x: spatial_vector, y: float32) -> spatial_vectorf +.. function:: mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: spatial_vector_t[~Scalar], y: Scalar) -> spatial_vector_t[~Scalar] -.. function:: mul(x: float16, y: spatial_vectorh) -> spatial_vectorh +.. function:: mul(x: float64, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float64, y: spatial_vectord) -> spatial_vectord +.. function:: mul(x: float16, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float32, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float32, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: spatial_vectorh) -> spatial_vectorh +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixd, y: spatial_vectord) -> spatial_vectord +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrix, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrix, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: matrix_t, y: vector_t) -> vector_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: float16) -> spatial_matrixh +.. function:: mul(x: spatial_matrix_t[], y: float64) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixd, y: float64) -> spatial_matrixd +.. function:: mul(x: spatial_matrix_t[], y: float16) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: float32) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: float32) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[] -.. function:: mul(x: matrix_t, y: Scalar) -> matrix_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: Scalar) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: float16, y: spatial_matrixh) -> spatial_matrixh +.. function:: mul(x: float64, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float64, y: spatial_matrixd) -> spatial_matrixd +.. function:: mul(x: float16, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float32, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float32, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: Scalar, y: matrix_t) -> matrix_t +.. function:: mul(x: Scalar, y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: transformh, y: transformh) -> transformh +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformd, y: transformd) -> transformd +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformf, y: transformf) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformf, y: transform) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform, y: transformf) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform, y: transform) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform_class, y: transform_class) -> transform_class +.. function:: mul(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: float16, y: transformh) -> transformh +.. function:: mul(x: float64, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float64, y: transformd) -> transformd +.. function:: mul(x: float16, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float32, y: transformf) -> transformf +.. function:: mul(x: float32, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float32, y: transform) -> transformf +.. function:: mul(x: float32, y: transform_t[]) -> transform_t[] -.. function:: mul(x: Scalar, y: transform_class) -> transform_class +.. function:: mul(x: Scalar, y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: transformh, y: float16) -> transformh +.. function:: mul(x: transform_t[], y: float64) -> transform_t[] -.. function:: mul(x: transformd, y: float64) -> transformd +.. function:: mul(x: transform_t[], y: float16) -> transform_t[] -.. function:: mul(x: transformf, y: float32) -> transformf +.. function:: mul(x: transform_t[], y: float32) -> transform_t[] -.. function:: mul(x: transform, y: float32) -> transformf +.. function:: mul(x: transform_t[], y: float32) -> transform_t[] -.. function:: mul(x: transform_class, y: Scalar) -> transform_class +.. function:: mul(x: transform_t[~Scalar], y: Scalar) -> transform_t[~Scalar] -.. function:: mod(x: int32, y: int32) -> int32 +.. function:: mod(x: uint32, y: uint32) -> uint32 -.. function:: mod(x: int8, y: int8) -> int8 +.. function:: mod(x: int16, y: int16) -> int16 .. function:: mod(x: float64, y: float64) -> float64 -.. function:: mod(x: int16, y: int16) -> int16 +.. function:: mod(x: int8, y: int8) -> int8 -.. function:: mod(x: uint32, y: uint32) -> uint32 +.. function:: mod(x: float16, y: float16) -> float16 -.. function:: mod(x: float16, y: float16) -> float16 +.. function:: mod(x: uint16, y: uint16) -> uint16 + + +.. function:: mod(x: int32, y: int32) -> int32 .. function:: mod(x: uint64, y: uint64) -> uint64 -.. function:: mod(x: uint16, y: uint16) -> uint16 +.. function:: mod(x: float32, y: float32) -> float32 .. function:: mod(x: int64, y: int64) -> int64 @@ -6062,34 +6065,34 @@ Operators .. function:: mod(x: uint8, y: uint8) -> uint8 -.. function:: mod(x: float32, y: float32) -> float32 - - .. function:: mod(x: Scalar, y: Scalar) -> Scalar -.. function:: div(x: int32, y: int32) -> int32 +.. function:: div(x: uint32, y: uint32) -> uint32 -.. function:: div(x: int8, y: int8) -> int8 +.. function:: div(x: int16, y: int16) -> int16 .. function:: div(x: float64, y: float64) -> float64 -.. function:: div(x: int16, y: int16) -> int16 +.. function:: div(x: int8, y: int8) -> int8 -.. function:: div(x: uint32, y: uint32) -> uint32 +.. function:: div(x: float16, y: float16) -> float16 -.. function:: div(x: float16, y: float16) -> float16 +.. function:: div(x: uint16, y: uint16) -> uint16 + + +.. function:: div(x: int32, y: int32) -> int32 .. function:: div(x: uint64, y: uint64) -> uint64 -.. function:: div(x: uint16, y: uint16) -> uint16 +.. function:: div(x: float32, y: float32) -> float32 .. function:: div(x: int64, y: int64) -> int64 @@ -6098,136 +6101,136 @@ Operators .. function:: div(x: uint8, y: uint8) -> uint8 -.. function:: div(x: float32, y: float32) -> float32 - - .. function:: div(x: Scalar, y: Scalar) -> Scalar -.. function:: div(x: vec2h, y: float16) -> vec2h +.. function:: div(x: vec[2, ], y: float64) -> vec[2, ] -.. function:: div(x: vec3h, y: float16) -> vec3h +.. function:: div(x: vec[3, ], y: float64) -> vec[3, ] -.. function:: div(x: vec4h, y: float16) -> vec4h +.. function:: div(x: vec[4, ], y: float64) -> vec[4, ] -.. function:: div(x: vec2d, y: float64) -> vec2d +.. function:: div(x: vec[2, ], y: float16) -> vec[2, ] -.. function:: div(x: vec3d, y: float64) -> vec3d +.. function:: div(x: vec[3, ], y: float16) -> vec[3, ] -.. function:: div(x: vec4d, y: float64) -> vec4d +.. function:: div(x: vec[4, ], y: float16) -> vec[4, ] -.. function:: div(x: vec2ub, y: uint8) -> vec2ub +.. function:: div(x: vec[2, ], y: uint8) -> vec[2, ] -.. function:: div(x: vec3ub, y: uint8) -> vec3ub +.. function:: div(x: vec[3, ], y: uint8) -> vec[3, ] -.. function:: div(x: vec4ub, y: uint8) -> vec4ub +.. function:: div(x: vec[4, ], y: uint8) -> vec[4, ] -.. function:: div(x: vec2f, y: float32) -> vec2f +.. function:: div(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: div(x: vec2, y: float32) -> vec2f +.. function:: div(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: div(x: vec3f, y: float32) -> vec3f +.. function:: div(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: div(x: vec3, y: float32) -> vec3f +.. function:: div(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: div(x: vec4f, y: float32) -> vec4f +.. function:: div(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: div(x: vec4, y: float32) -> vec4f +.. function:: div(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: div(x: vector_t, y: Scalar) -> vector_t +.. function:: div(x: vec[typing.Any, ~Scalar], y: Scalar) -> vec[typing.Any, ~Scalar] -.. function:: div(x: mat22h, y: float16) -> mat22h +.. function:: div(x: mat[2, 2, ], y: float64) -> mat[2, 2, ] -.. function:: div(x: mat33h, y: float16) -> mat33h +.. function:: div(x: mat[3, 3, ], y: float64) -> mat[3, 3, ] -.. function:: div(x: mat44h, y: float16) -> mat44h +.. function:: div(x: mat[4, 4, ], y: float64) -> mat[4, 4, ] -.. function:: div(x: mat22d, y: float64) -> mat22d +.. function:: div(x: mat[2, 2, ], y: float16) -> mat[2, 2, ] -.. function:: div(x: mat33d, y: float64) -> mat33d +.. function:: div(x: mat[3, 3, ], y: float16) -> mat[3, 3, ] -.. function:: div(x: mat44d, y: float64) -> mat44d +.. function:: div(x: mat[4, 4, ], y: float16) -> mat[4, 4, ] -.. function:: div(x: mat22f, y: float32) -> mat22f +.. function:: div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: div(x: mat22, y: float32) -> mat22f +.. function:: div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: div(x: mat33f, y: float32) -> mat33f +.. function:: div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: div(x: mat33, y: float32) -> mat33f +.. function:: div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: div(x: mat44f, y: float32) -> mat44f +.. function:: div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: div(x: mat44, y: float32) -> mat44f +.. function:: div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: div(x: matrix_t, y: Scalar) -> matrix_t +.. function:: div(x: mat[typing.Any, typing.Any, ~Scalar], y: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: div(x: quath, y: float16) -> quath +.. function:: div(x: quaternion[], y: float64) -> quaternion[] -.. function:: div(x: quatd, y: float64) -> quatd +.. function:: div(x: quaternion[], y: float16) -> quaternion[] -.. function:: div(x: quatf, y: float32) -> quatf +.. function:: div(x: quaternion[], y: float32) -> quaternion[] -.. function:: div(x: quat, y: float32) -> quatf +.. function:: div(x: quaternion[], y: float32) -> quaternion[] -.. function:: div(x: vector_t, y: Scalar) -> vector_t +.. function:: div(x: quaternion[~Scalar], y: Scalar) -> quaternion[~Scalar] -.. function:: floordiv(x: int32, y: int32) -> int32 +.. function:: floordiv(x: uint32, y: uint32) -> uint32 -.. function:: floordiv(x: int8, y: int8) -> int8 +.. function:: floordiv(x: int16, y: int16) -> int16 .. function:: floordiv(x: float64, y: float64) -> float64 -.. function:: floordiv(x: int16, y: int16) -> int16 +.. function:: floordiv(x: int8, y: int8) -> int8 -.. function:: floordiv(x: uint32, y: uint32) -> uint32 +.. function:: floordiv(x: float16, y: float16) -> float16 -.. function:: floordiv(x: float16, y: float16) -> float16 +.. function:: floordiv(x: uint16, y: uint16) -> uint16 + + +.. function:: floordiv(x: int32, y: int32) -> int32 .. function:: floordiv(x: uint64, y: uint64) -> uint64 -.. function:: floordiv(x: uint16, y: uint16) -> uint16 +.. function:: floordiv(x: float32, y: float32) -> float32 .. function:: floordiv(x: int64, y: int64) -> int64 @@ -6236,34 +6239,34 @@ Operators .. function:: floordiv(x: uint8, y: uint8) -> uint8 -.. function:: floordiv(x: float32, y: float32) -> float32 - - .. function:: floordiv(x: Scalar, y: Scalar) -> Scalar -.. function:: neg(x: int32) -> int32 +.. function:: neg(x: uint32) -> uint32 -.. function:: neg(x: int8) -> int8 +.. function:: neg(x: int16) -> int16 .. function:: neg(x: float64) -> float64 -.. function:: neg(x: int16) -> int16 +.. function:: neg(x: int8) -> int8 -.. function:: neg(x: uint32) -> uint32 +.. function:: neg(x: float16) -> float16 -.. function:: neg(x: float16) -> float16 +.. function:: neg(x: uint16) -> uint16 + + +.. function:: neg(x: int32) -> int32 .. function:: neg(x: uint64) -> uint64 -.. function:: neg(x: uint16) -> uint16 +.. function:: neg(x: float32) -> float32 .. function:: neg(x: int64) -> int64 @@ -6272,112 +6275,109 @@ Operators .. function:: neg(x: uint8) -> uint8 -.. function:: neg(x: float32) -> float32 - - .. function:: neg(x: Scalar) -> Scalar -.. function:: neg(x: vec2h) -> vec2h +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec3h) -> vec3h +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec4h) -> vec4h +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec2d) -> vec2d +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec3d) -> vec3d +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec4d) -> vec4d +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec2ub) -> vec2ub +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec3ub) -> vec3ub +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec4ub) -> vec4ub +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec2f) -> vec2f +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec2) -> vec2f +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec3f) -> vec3f +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec3) -> vec3f +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec4f) -> vec4f +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec4) -> vec4f +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vector_t) -> vector_t +.. function:: neg(x: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: neg(x: quath) -> quath +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quatd) -> quatd +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quatf) -> quatf +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quat) -> quatf +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: vector_t) -> vector_t +.. function:: neg(x: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: neg(x: mat22h) -> mat22h +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat33h) -> mat33h +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat44h) -> mat44h +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat22d) -> mat22d +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat33d) -> mat33d +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat44d) -> mat44d +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat22f) -> mat22f +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat22) -> mat22f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat33f) -> mat33f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat33) -> mat33f +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat44f) -> mat44f +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat44) -> mat44f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: matrix_t) -> matrix_t +.. function:: neg(x: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] .. function:: unot(b: bool) -> bool diff --git a/docs/_build/html/genindex.html b/docs/_build/html/genindex.html index 1d5108b17..b47a5c8b9 100644 --- a/docs/_build/html/genindex.html +++ b/docs/_build/html/genindex.html @@ -69,7 +69,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/index.html b/docs/_build/html/index.html index 4c7040f2c..d8eb94fd3 100644 --- a/docs/_build/html/index.html +++ b/docs/_build/html/index.html @@ -70,7 +70,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/modules/functions.html b/docs/_build/html/modules/functions.html index 5b1fd4a33..5ccc6cd2c 100644 --- a/docs/_build/html/modules/functions.html +++ b/docs/_build/html/modules/functions.html @@ -71,7 +71,7 @@
- 0.7.1 + 0.7.2
@@ -466,13 +466,13 @@

Vector Types¶

-warp.min(x: int32, y: int32) → int32¶
+warp.min(x: uint32, y: uint32) → uint32¶

Return the minimum of two scalars.

-warp.min(x: int8, y: int8) → int8¶
+warp.min(x: int16, y: int16) → int16¶

Return the minimum of two scalars.

@@ -484,49 +484,49 @@

Scalar Math
-warp.min(x: int16, y: int16) → int16¶
+warp.min(x: int8, y: int8) → int8¶

Return the minimum of two scalars.

-warp.min(x: uint32, y: uint32) → uint32¶
+warp.min(x: float16, y: float16) → float16¶

Return the minimum of two scalars.

-warp.min(x: float16, y: float16) → float16¶
+warp.min(x: uint16, y: uint16) → uint16¶

Return the minimum of two scalars.

-warp.min(x: uint64, y: uint64) → uint64¶
+warp.min(x: int32, y: int32) → int32¶

Return the minimum of two scalars.

-warp.min(x: uint16, y: uint16) → uint16¶
+warp.min(x: uint64, y: uint64) → uint64¶

Return the minimum of two scalars.

-warp.min(x: int64, y: int64) → int64¶
+warp.min(x: float32, y: float32) → float32¶

Return the minimum of two scalars.

-warp.min(x: uint8, y: uint8) → uint8¶
+warp.min(x: int64, y: int64) → int64¶

Return the minimum of two scalars.

-warp.min(x: float32, y: float32) → float32¶
+warp.min(x: uint8, y: uint8) → uint8¶

Return the minimum of two scalars.

@@ -538,145 +538,145 @@

Scalar Math
-warp.min(x: vec2h, y: vec2h) → vec2h¶
+warp.min(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3h, y: vec3h) → vec3h¶
+warp.min(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4h, y: vec4h) → vec4h¶
+warp.min(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2d, y: vec2d) → vec2d¶
+warp.min(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3d, y: vec3d) → vec3d¶
+warp.min(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4d, y: vec4d) → vec4d¶
+warp.min(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.min(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.min(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.min(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2f, y: vec2f) → vec2f¶
+warp.min(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2f, y: vec2) → vec2f¶
+warp.min(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2, y: vec2f) → vec2f¶
+warp.min(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec2, y: vec2) → vec2f¶
+warp.min(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3f, y: vec3f) → vec3f¶
+warp.min(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3f, y: vec3) → vec3f¶
+warp.min(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3, y: vec3f) → vec3f¶
+warp.min(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec3, y: vec3) → vec3f¶
+warp.min(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4f, y: vec4f) → vec4f¶
+warp.min(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4f, y: vec4) → vec4f¶
+warp.min(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4, y: vec4f) → vec4f¶
+warp.min(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vec4, y: vec4) → vec4f¶
+warp.min(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶

Return the element wise minimum of two vectors.

-warp.min(x: vector_t, y: vector_t) → vector_t¶
+warp.min(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶

Return the element wise minimum of two vectors.

-warp.max(x: int32, y: int32) → int32¶
+warp.max(x: uint32, y: uint32) → uint32¶

Return the maximum of two scalars.

-warp.max(x: int8, y: int8) → int8¶
+warp.max(x: int16, y: int16) → int16¶

Return the maximum of two scalars.

@@ -688,49 +688,49 @@

Scalar Math
-warp.max(x: int16, y: int16) → int16¶
+warp.max(x: int8, y: int8) → int8¶

Return the maximum of two scalars.

-warp.max(x: uint32, y: uint32) → uint32¶
+warp.max(x: float16, y: float16) → float16¶

Return the maximum of two scalars.

-warp.max(x: float16, y: float16) → float16¶
+warp.max(x: uint16, y: uint16) → uint16¶

Return the maximum of two scalars.

-warp.max(x: uint64, y: uint64) → uint64¶
+warp.max(x: int32, y: int32) → int32¶

Return the maximum of two scalars.

-warp.max(x: uint16, y: uint16) → uint16¶
+warp.max(x: uint64, y: uint64) → uint64¶

Return the maximum of two scalars.

-warp.max(x: int64, y: int64) → int64¶
+warp.max(x: float32, y: float32) → float32¶

Return the maximum of two scalars.

-warp.max(x: uint8, y: uint8) → uint8¶
+warp.max(x: int64, y: int64) → int64¶

Return the maximum of two scalars.

-warp.max(x: float32, y: float32) → float32¶
+warp.max(x: uint8, y: uint8) → uint8¶

Return the maximum of two scalars.

@@ -742,145 +742,145 @@

Scalar Math
-warp.max(x: vec2h, y: vec2h) → vec2h¶
+warp.max(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3h, y: vec3h) → vec3h¶
+warp.max(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4h, y: vec4h) → vec4h¶
+warp.max(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2d, y: vec2d) → vec2d¶
+warp.max(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3d, y: vec3d) → vec3d¶
+warp.max(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4d, y: vec4d) → vec4d¶
+warp.max(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.max(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.max(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.max(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2f, y: vec2f) → vec2f¶
+warp.max(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2f, y: vec2) → vec2f¶
+warp.max(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2, y: vec2f) → vec2f¶
+warp.max(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec2, y: vec2) → vec2f¶
+warp.max(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3f, y: vec3f) → vec3f¶
+warp.max(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3f, y: vec3) → vec3f¶
+warp.max(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3, y: vec3f) → vec3f¶
+warp.max(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec3, y: vec3) → vec3f¶
+warp.max(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4f, y: vec4f) → vec4f¶
+warp.max(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4f, y: vec4) → vec4f¶
+warp.max(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4, y: vec4f) → vec4f¶
+warp.max(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vec4, y: vec4) → vec4f¶
+warp.max(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶

Return the element wise maximum of two vectors.

-warp.max(x: vector_t, y: vector_t) → vector_t¶
+warp.max(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶

Return the element wise maximum of two vectors.

-warp.clamp(x: int32, a: int32, b: int32) → int32¶
+warp.clamp(x: uint32, a: uint32, b: uint32) → uint32¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: int8, a: int8, b: int8) → int8¶
+warp.clamp(x: int16, a: int16, b: int16) → int16¶

Clamp the value of x to the range [a, b].

@@ -892,49 +892,49 @@

Scalar Math
-warp.clamp(x: int16, a: int16, b: int16) → int16¶
+warp.clamp(x: int8, a: int8, b: int8) → int8¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: uint32, a: uint32, b: uint32) → uint32¶
+warp.clamp(x: float16, a: float16, b: float16) → float16¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: float16, a: float16, b: float16) → float16¶
+warp.clamp(x: uint16, a: uint16, b: uint16) → uint16¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: uint64, a: uint64, b: uint64) → uint64¶
+warp.clamp(x: int32, a: int32, b: int32) → int32¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: uint16, a: uint16, b: uint16) → uint16¶
+warp.clamp(x: uint64, a: uint64, b: uint64) → uint64¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: int64, a: int64, b: int64) → int64¶
+warp.clamp(x: float32, a: float32, b: float32) → float32¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: uint8, a: uint8, b: uint8) → uint8¶
+warp.clamp(x: int64, a: int64, b: int64) → int64¶

Clamp the value of x to the range [a, b].

-warp.clamp(x: float32, a: float32, b: float32) → float32¶
+warp.clamp(x: uint8, a: uint8, b: uint8) → uint8¶

Clamp the value of x to the range [a, b].

@@ -946,13 +946,13 @@

Scalar Math
-warp.abs(x: int32) → int32¶
+warp.abs(x: uint32) → uint32¶

Return the absolute value of x.

-warp.abs(x: int8) → int8¶
+warp.abs(x: int16) → int16¶

Return the absolute value of x.

@@ -964,49 +964,49 @@

Scalar Math
-warp.abs(x: int16) → int16¶
+warp.abs(x: int8) → int8¶

Return the absolute value of x.

-warp.abs(x: uint32) → uint32¶
+warp.abs(x: float16) → float16¶

Return the absolute value of x.

-warp.abs(x: float16) → float16¶
+warp.abs(x: uint16) → uint16¶

Return the absolute value of x.

-warp.abs(x: uint64) → uint64¶
+warp.abs(x: int32) → int32¶

Return the absolute value of x.

-warp.abs(x: uint16) → uint16¶
+warp.abs(x: uint64) → uint64¶

Return the absolute value of x.

-warp.abs(x: int64) → int64¶
+warp.abs(x: float32) → float32¶

Return the absolute value of x.

-warp.abs(x: uint8) → uint8¶
+warp.abs(x: int64) → int64¶

Return the absolute value of x.

-warp.abs(x: float32) → float32¶
+warp.abs(x: uint8) → uint8¶

Return the absolute value of x.

@@ -1018,13 +1018,13 @@

Scalar Math
-warp.sign(x: int32) → int32¶
+warp.sign(x: uint32) → uint32¶

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

-warp.sign(x: int8) → int8¶
+warp.sign(x: int16) → int16¶

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

@@ -1036,49 +1036,49 @@

Scalar Math
-warp.sign(x: int16) → int16¶
+warp.sign(x: int8) → int8¶

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

-warp.sign(x: uint32) → uint32¶
+warp.sign(x: float16) → float16¶

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

-warp.sign(x: float16) → float16¶
+warp.sign(x: uint16) → uint16¶

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

-warp.sign(x: uint64) → uint64¶
+warp.sign(x: int32) → int32¶

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

-warp.sign(x: uint16) → uint16¶
+warp.sign(x: uint64) → uint64¶

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

-warp.sign(x: int64) → int64¶
+warp.sign(x: float32) → float32¶

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

-warp.sign(x: uint8) → uint8¶
+warp.sign(x: int64) → int64¶

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

-warp.sign(x: float32) → float32¶
+warp.sign(x: uint8) → uint8¶

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

@@ -1090,13 +1090,13 @@

Scalar Math
-warp.step(x: int32) → int32¶
+warp.step(x: uint32) → uint32¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: int8) → int8¶
+warp.step(x: int16) → int16¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

@@ -1108,49 +1108,49 @@

Scalar Math
-warp.step(x: int16) → int16¶
+warp.step(x: int8) → int8¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: uint32) → uint32¶
+warp.step(x: float16) → float16¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: float16) → float16¶
+warp.step(x: uint16) → uint16¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: uint64) → uint64¶
+warp.step(x: int32) → int32¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: uint16) → uint16¶
+warp.step(x: uint64) → uint64¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: int64) → int64¶
+warp.step(x: float32) → float32¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: uint8) → uint8¶
+warp.step(x: int64) → int64¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

-warp.step(x: float32) → float32¶
+warp.step(x: uint8) → uint8¶

Return 1.0 if x < 0.0, return 0.0 otherwise.

@@ -1162,13 +1162,13 @@

Scalar Math
-warp.nonzero(x: int32) → int32¶
+warp.nonzero(x: uint32) → uint32¶

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

-warp.nonzero(x: int8) → int8¶
+warp.nonzero(x: int16) → int16¶

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

@@ -1180,49 +1180,49 @@

Scalar Math
-warp.nonzero(x: int16) → int16¶
+warp.nonzero(x: int8) → int8¶

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

-warp.nonzero(x: uint32) → uint32¶
+warp.nonzero(x: float16) → float16¶

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

-warp.nonzero(x: float16) → float16¶
+warp.nonzero(x: uint16) → uint16¶

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

-warp.nonzero(x: uint64) → uint64¶
+warp.nonzero(x: int32) → int32¶

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

-warp.nonzero(x: uint16) → uint16¶
+warp.nonzero(x: uint64) → uint64¶

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

-warp.nonzero(x: int64) → int64¶
+warp.nonzero(x: float32) → float32¶

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

-warp.nonzero(x: uint8) → uint8¶
+warp.nonzero(x: int64) → int64¶

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

-warp.nonzero(x: float32) → float32¶
+warp.nonzero(x: uint8) → uint8¶

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

@@ -1234,19 +1234,19 @@

Scalar Math
-warp.sin(x: float16) → float16¶
+warp.sin(x: float64) → float64¶

Return the sine of x in radians.

-warp.sin(x: float64) → float64¶
+warp.sin(x: float32) → float32¶

Return the sine of x in radians.

-warp.sin(x: float32) → float32¶
+warp.sin(x: float16) → float16¶

Return the sine of x in radians.

@@ -1258,19 +1258,19 @@

Scalar Math
-warp.cos(x: float16) → float16¶
+warp.cos(x: float64) → float64¶

Return the cosine of x in radians.

-warp.cos(x: float64) → float64¶
+warp.cos(x: float32) → float32¶

Return the cosine of x in radians.

-warp.cos(x: float32) → float32¶
+warp.cos(x: float16) → float16¶

Return the cosine of x in radians.

@@ -1282,19 +1282,19 @@

Scalar Math
-warp.acos(x: float16) → float16¶
+warp.acos(x: float64) → float64¶

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

-warp.acos(x: float64) → float64¶
+warp.acos(x: float32) → float32¶

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

-warp.acos(x: float32) → float32¶
+warp.acos(x: float16) → float16¶

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

@@ -1306,19 +1306,19 @@

Scalar Math
-warp.asin(x: float16) → float16¶
+warp.asin(x: float64) → float64¶

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

-warp.asin(x: float64) → float64¶
+warp.asin(x: float32) → float32¶

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

-warp.asin(x: float32) → float32¶
+warp.asin(x: float16) → float16¶

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

@@ -1330,19 +1330,19 @@

Scalar Math
-warp.sqrt(x: float16) → float16¶
+warp.sqrt(x: float64) → float64¶

Return the sqrt of x, where x is positive.

-warp.sqrt(x: float64) → float64¶
+warp.sqrt(x: float32) → float32¶

Return the sqrt of x, where x is positive.

-warp.sqrt(x: float32) → float32¶
+warp.sqrt(x: float16) → float16¶

Return the sqrt of x, where x is positive.

@@ -1354,19 +1354,19 @@

Scalar Math
-warp.tan(x: float16) → float16¶
+warp.tan(x: float64) → float64¶

Return tangent of x in radians.

-warp.tan(x: float64) → float64¶
+warp.tan(x: float32) → float32¶

Return tangent of x in radians.

-warp.tan(x: float32) → float32¶
+warp.tan(x: float16) → float16¶

Return tangent of x in radians.

@@ -1378,19 +1378,19 @@

Scalar Math
-warp.atan(x: float16) → float16¶
+warp.atan(x: float64) → float64¶

Return arctan of x.

-warp.atan(x: float64) → float64¶
+warp.atan(x: float32) → float32¶

Return arctan of x.

-warp.atan(x: float32) → float32¶
+warp.atan(x: float16) → float16¶

Return arctan of x.

@@ -1402,19 +1402,19 @@

Scalar Math
-warp.atan2(y: float16, x: float16) → float16¶
+warp.atan2(y: float64, x: float64) → float64¶

Return atan2 of x.

-warp.atan2(y: float64, x: float64) → float64¶
+warp.atan2(y: float32, x: float32) → float32¶

Return atan2 of x.

-warp.atan2(y: float32, x: float32) → float32¶
+warp.atan2(y: float16, x: float16) → float16¶

Return atan2 of x.

@@ -1426,19 +1426,19 @@

Scalar Math
-warp.sinh(x: float16) → float16¶
+warp.sinh(x: float64) → float64¶

Return the sinh of x.

-warp.sinh(x: float64) → float64¶
+warp.sinh(x: float32) → float32¶

Return the sinh of x.

-warp.sinh(x: float32) → float32¶
+warp.sinh(x: float16) → float16¶

Return the sinh of x.

@@ -1450,19 +1450,19 @@

Scalar Math
-warp.cosh(x: float16) → float16¶
+warp.cosh(x: float64) → float64¶

Return the cosh of x.

-warp.cosh(x: float64) → float64¶
+warp.cosh(x: float32) → float32¶

Return the cosh of x.

-warp.cosh(x: float32) → float32¶
+warp.cosh(x: float16) → float16¶

Return the cosh of x.

@@ -1474,19 +1474,19 @@

Scalar Math
-warp.tanh(x: float16) → float16¶
+warp.tanh(x: float64) → float64¶

Return the tanh of x.

-warp.tanh(x: float64) → float64¶
+warp.tanh(x: float32) → float32¶

Return the tanh of x.

-warp.tanh(x: float32) → float32¶
+warp.tanh(x: float16) → float16¶

Return the tanh of x.

@@ -1510,19 +1510,19 @@

Scalar Math
-warp.log(x: float16) → float16¶
+warp.log(x: float64) → float64¶

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

-warp.log(x: float64) → float64¶
+warp.log(x: float32) → float32¶

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

-warp.log(x: float32) → float32¶
+warp.log(x: float16) → float16¶

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

@@ -1534,19 +1534,19 @@

Scalar Math
-warp.log2(x: float16) → float16¶
+warp.log2(x: float64) → float64¶

Return the natural log (base-2) of x, where x is positive.

-warp.log2(x: float64) → float64¶
+warp.log2(x: float32) → float32¶

Return the natural log (base-2) of x, where x is positive.

-warp.log2(x: float32) → float32¶
+warp.log2(x: float16) → float16¶

Return the natural log (base-2) of x, where x is positive.

@@ -1558,19 +1558,19 @@

Scalar Math
-warp.log10(x: float16) → float16¶
+warp.log10(x: float64) → float64¶

Return the natural log (base-10) of x, where x is positive.

-warp.log10(x: float64) → float64¶
+warp.log10(x: float32) → float32¶

Return the natural log (base-10) of x, where x is positive.

-warp.log10(x: float32) → float32¶
+warp.log10(x: float16) → float16¶

Return the natural log (base-10) of x, where x is positive.

@@ -1582,19 +1582,19 @@

Scalar Math
-warp.exp(x: float16) → float16¶
+warp.exp(x: float64) → float64¶

Return base-e exponential, e^x.

-warp.exp(x: float64) → float64¶
+warp.exp(x: float32) → float32¶

Return base-e exponential, e^x.

-warp.exp(x: float32) → float32¶
+warp.exp(x: float16) → float16¶

Return base-e exponential, e^x.

@@ -1606,19 +1606,19 @@

Scalar Math
-warp.pow(x: float16, y: float16) → float16¶
+warp.pow(x: float64, y: float64) → float64¶

Return the result of x raised to power of y.

-warp.pow(x: float64, y: float64) → float64¶
+warp.pow(x: float32, y: float32) → float32¶

Return the result of x raised to power of y.

-warp.pow(x: float32, y: float32) → float32¶
+warp.pow(x: float16, y: float16) → float16¶

Return the result of x raised to power of y.

@@ -1630,7 +1630,7 @@

Scalar Math
-warp.round(x: float16) → float16¶
+warp.round(x: float64) → float64¶

Calculate the nearest integer value, rounding halfway cases away from zero.

@@ -1638,7 +1638,7 @@

Scalar Mathnumpy.round(), which behaves the same way as numpy.rint().

-warp.round(x: float64) → float64¶
+warp.round(x: float32) → float32¶

Calculate the nearest integer value, rounding halfway cases away from zero.

@@ -1646,7 +1646,7 @@

Scalar Mathnumpy.round(), which behaves the same way as numpy.rint().

-warp.round(x: float32) → float32¶
+warp.round(x: float16) → float16¶

Calculate the nearest integer value, rounding halfway cases away from zero.

@@ -1662,7 +1662,7 @@

Scalar Mathnumpy.round(), which behaves the same way as numpy.rint().

-warp.rint(x: float16) → float16¶
+warp.rint(x: float64) → float64¶

Calculate the nearest integer value, rounding halfway cases to nearest even integer.

@@ -1670,7 +1670,7 @@

Scalar Mathnumpy.rint().

-warp.rint(x: float64) → float64¶
+warp.rint(x: float32) → float32¶

Calculate the nearest integer value, rounding halfway cases to nearest even integer.

@@ -1678,7 +1678,7 @@

Scalar Mathnumpy.rint().

-warp.rint(x: float32) → float32¶
+warp.rint(x: float16) → float16¶

Calculate the nearest integer value, rounding halfway cases to nearest even integer.

@@ -1694,7 +1694,7 @@

Scalar Mathnumpy.rint().

-warp.trunc(x: float16) → float16¶
+warp.trunc(x: float64) → float64¶

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

@@ -1703,7 +1703,7 @@

Scalar Mathnumpy.trunc() and numpy.fix().

-warp.trunc(x: float64) → float64¶
+warp.trunc(x: float32) → float32¶

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

@@ -1712,7 +1712,7 @@

Scalar Mathnumpy.trunc() and numpy.fix().

-warp.trunc(x: float32) → float32¶
+warp.trunc(x: float16) → float16¶

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

@@ -1730,19 +1730,19 @@

Scalar Mathnumpy.trunc() and numpy.fix().

-warp.floor(x: float16) → float16¶
+warp.floor(x: float64) → float64¶

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

-warp.floor(x: float64) → float64¶
+warp.floor(x: float32) → float32¶

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

-warp.floor(x: float32) → float32¶
+warp.floor(x: float16) → float16¶

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

@@ -1754,19 +1754,19 @@

Scalar Math
-warp.ceil(x: float16) → float16¶
+warp.ceil(x: float64) → float64¶

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

-warp.ceil(x: float64) → float64¶
+warp.ceil(x: float32) → float32¶

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

-warp.ceil(x: float32) → float32¶
+warp.ceil(x: float16) → float16¶

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

@@ -1781,2084 +1781,2084 @@

Scalar Math¶

-warp.dot(x: vec2h, y: vec2h) → float16¶
+warp.dot(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → float64¶

Compute the dot product between two vectors.

-warp.dot(x: vec3h, y: vec3h) → float16¶
+warp.dot(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → float64¶

Compute the dot product between two vectors.

-warp.dot(x: vec4h, y: vec4h) → float16¶
+warp.dot(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → float64¶

Compute the dot product between two vectors.

-warp.dot(x: vec2d, y: vec2d) → float64¶
+warp.dot(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec3d, y: vec3d) → float64¶
+warp.dot(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec4d, y: vec4d) → float64¶
+warp.dot(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec2ub, y: vec2ub) → uint8¶
+warp.dot(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec3ub, y: vec3ub) → uint8¶
+warp.dot(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec4ub, y: vec4ub) → uint8¶
+warp.dot(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec2f, y: vec2f) → float32¶
+warp.dot(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec2f, y: vec2) → float32¶
+warp.dot(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec2, y: vec2f) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec2, y: vec2) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec3f, y: vec3f) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec3f, y: vec3) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the dot product between two vectors.

-warp.dot(x: vec3, y: vec3f) → float32¶
+warp.dot(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → uint8¶

Compute the dot product between two vectors.

-warp.dot(x: vec3, y: vec3) → float32¶
+warp.dot(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → uint8¶

Compute the dot product between two vectors.

-warp.dot(x: vec4f, y: vec4f) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → uint8¶

Compute the dot product between two vectors.

-warp.dot(x: vec4f, y: vec4) → float32¶
+warp.dot(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → float16¶

Compute the dot product between two vectors.

-warp.dot(x: vec4, y: vec4f) → float32¶
+warp.dot(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → float16¶

Compute the dot product between two vectors.

-warp.dot(x: vec4, y: vec4) → float32¶
+warp.dot(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → float16¶

Compute the dot product between two vectors.

-warp.dot(x: vector_t, y: vector_t) → Scalar¶
+warp.dot(x: vec[Any, Scalar], y: vec[Any, Scalar]) → Scalar¶

Compute the dot product between two vectors.

-warp.dot(x: quath, y: quath) → float16¶
+warp.dot(x: quaternion[<class 'warp.types.float64'>], y: quaternion[<class 'warp.types.float64'>]) → float64¶

Compute the dot product between two quaternions.

-warp.dot(x: quatd, y: quatd) → float64¶
+warp.dot(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the dot product between two quaternions.

-warp.dot(x: quatf, y: quatf) → float32¶
+warp.dot(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the dot product between two quaternions.

-warp.dot(x: quatf, y: quat) → float32¶
+warp.dot(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the dot product between two quaternions.

-warp.dot(x: quat, y: quatf) → float32¶
+warp.dot(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the dot product between two quaternions.

-warp.dot(x: quat, y: quat) → float32¶
+warp.dot(x: quaternion[<class 'warp.types.float16'>], y: quaternion[<class 'warp.types.float16'>]) → float16¶

Compute the dot product between two quaternions.

-warp.dot(x: vector_t, y: vector_t) → Scalar¶
+warp.dot(x: quaternion[Float], y: quaternion[Float]) → Scalar¶

Compute the dot product between two quaternions.

-warp.ddot(x: mat22h, y: mat22h) → float16¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → float64¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33h, y: mat33h) → float16¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → float64¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44h, y: mat44h) → float16¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → float64¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat22d, y: mat22d) → float64¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33d, y: mat33d) → float64¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44d, y: mat44d) → float64¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat22f, y: mat22f) → float32¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat22f, y: mat22) → float32¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat22, y: mat22f) → float32¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat22, y: mat22) → float32¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33f, y: mat33f) → float32¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33f, y: mat33) → float32¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33, y: mat33f) → float32¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat33, y: mat33) → float32¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44f, y: mat44f) → float32¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44f, y: mat44) → float32¶
+warp.ddot(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → float16¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44, y: mat44f) → float32¶
+warp.ddot(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → float16¶

Compute the double dot product between two matrices.

-warp.ddot(x: mat44, y: mat44) → float32¶
+warp.ddot(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → float16¶

Compute the double dot product between two matrices.

-warp.ddot(x: matrix_t, y: matrix_t) → Scalar¶
+warp.ddot(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar]) → Scalar¶

Compute the double dot product between two matrices.

-warp.outer(x: vec2h, y: vec2h) → mat22h¶
+warp.outer(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3h, y: vec3h) → mat33h¶
+warp.outer(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4h, y: vec4h) → mat44h¶
+warp.outer(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec2d, y: vec2d) → mat22d¶
+warp.outer(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3d, y: vec3d) → mat33d¶
+warp.outer(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4d, y: vec4d) → mat44d¶
+warp.outer(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec2f, y: vec2f) → mat22f¶
+warp.outer(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec2f, y: vec2) → mat22f¶
+warp.outer(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec2, y: vec2f) → mat22f¶
+warp.outer(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec2, y: vec2) → mat22f¶
+warp.outer(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3f, y: vec3f) → mat33f¶
+warp.outer(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3f, y: vec3) → mat33f¶
+warp.outer(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3, y: vec3f) → mat33f¶
+warp.outer(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec3, y: vec3) → mat33f¶
+warp.outer(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4f, y: vec4f) → mat44f¶
+warp.outer(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4f, y: vec4) → mat44f¶
+warp.outer(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4, y: vec4f) → mat44f¶
+warp.outer(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vec4, y: vec4) → mat44f¶
+warp.outer(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: vector_t, y: vector_t) → matrix_t¶
+warp.outer(x: vec[Any, Scalar], y: vec[Any, Scalar]) → mat[Any, Any, Scalar]¶

Compute the outer product x*y^T for two vec2 objects.

-warp.outer(x: spatial_vectorh, y: spatial_vectorh) → spatial_matrixh¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float64'>], y: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: spatial_vectord, y: spatial_vectord) → spatial_matrixd¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: spatial_vectorf, y: spatial_vectorf) → spatial_matrixf¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: spatial_vectorf, y: spatial_vector) → spatial_matrixf¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: spatial_vector, y: spatial_vectorf) → spatial_matrixf¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: spatial_vector, y: spatial_vector) → spatial_matrixf¶
+warp.outer(x: spatial_vector_t[<class 'warp.types.float16'>], y: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.outer(x: vector_t, y: vector_t) → matrix_t¶
+warp.outer(x: spatial_vector_t[Float], y: spatial_vector_t[Float]) → spatial_matrix_t[Float]¶

Compute the outer product x*y^T for two spatial_vector objects.

-warp.cross(x: vec3h, y: vec3h) → vec3h¶
+warp.cross(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3d, y: vec3d) → vec3d¶
+warp.cross(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.cross(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3f, y: vec3f) → vec3f¶
+warp.cross(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3f, y: vec3) → vec3f¶
+warp.cross(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3, y: vec3f) → vec3f¶
+warp.cross(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vec3, y: vec3) → vec3f¶
+warp.cross(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Compute the cross product of two 3d vectors.

-warp.cross(x: vector_t, y: vector_t) → vector_t¶
+warp.cross(x: vec[3, Scalar], y: vec[3, Scalar]) → vec[3, Scalar]¶

Compute the cross product of two 3d vectors.

-warp.skew(x: vec3h) → mat33h¶
+warp.skew(x: vec[3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Compute the skew symmetric matrix for a 3d vector.

-warp.skew(x: vec3d) → mat33d¶
+warp.skew(x: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the skew symmetric matrix for a 3d vector.

-warp.skew(x: vec3f) → mat33f¶
+warp.skew(x: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Compute the skew symmetric matrix for a 3d vector.

-warp.skew(x: vec3) → mat33f¶
+warp.skew(x: vec[3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Compute the skew symmetric matrix for a 3d vector.

-warp.skew(x: vector_t)¶
+warp.skew(x: vec[3, Scalar])¶

Compute the skew symmetric matrix for a 3d vector.

-warp.length(x: vec2h) → float16¶
+warp.length(x: vec[2, <class 'warp.types.float64'>]) → float64¶

Compute the length of a vector.

-warp.length(x: vec3h) → float16¶
+warp.length(x: vec[3, <class 'warp.types.float64'>]) → float64¶

Compute the length of a vector.

-warp.length(x: vec4h) → float16¶
+warp.length(x: vec[4, <class 'warp.types.float64'>]) → float64¶

Compute the length of a vector.

-warp.length(x: vec2d) → float64¶
+warp.length(x: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec3d) → float64¶
+warp.length(x: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec4d) → float64¶
+warp.length(x: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec2f) → float32¶
+warp.length(x: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec2) → float32¶
+warp.length(x: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec3f) → float32¶
+warp.length(x: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the length of a vector.

-warp.length(x: vec3) → float32¶
+warp.length(x: vec[2, <class 'warp.types.float16'>]) → float16¶

Compute the length of a vector.

-warp.length(x: vec4f) → float32¶
+warp.length(x: vec[3, <class 'warp.types.float16'>]) → float16¶

Compute the length of a vector.

-warp.length(x: vec4) → float32¶
+warp.length(x: vec[4, <class 'warp.types.float16'>]) → float16¶

Compute the length of a vector.

-warp.length(x: vector_t) → Scalar¶
+warp.length(x: vec[Any, Float]) → Scalar¶

Compute the length of a vector.

-warp.length(x: quath) → float16¶
+warp.length(x: quaternion[<class 'warp.types.float64'>]) → float64¶

Compute the length of a quaternion.

-warp.length(x: quatd) → float64¶
+warp.length(x: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the length of a quaternion.

-warp.length(x: quatf) → float32¶
+warp.length(x: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the length of a quaternion.

-warp.length(x: quat) → float32¶
+warp.length(x: quaternion[<class 'warp.types.float16'>]) → float16¶

Compute the length of a quaternion.

-warp.length(x: vector_t) → Scalar¶
+warp.length(x: quaternion[Float]) → Scalar¶

Compute the length of a quaternion.

-warp.length_sq(x: vec2h) → float16¶
+warp.length_sq(x: vec[2, <class 'warp.types.float64'>]) → float64¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec3h) → float16¶
+warp.length_sq(x: vec[3, <class 'warp.types.float64'>]) → float64¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec4h) → float16¶
+warp.length_sq(x: vec[4, <class 'warp.types.float64'>]) → float64¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec2d) → float64¶
+warp.length_sq(x: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec3d) → float64¶
+warp.length_sq(x: vec[2, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec4d) → float64¶
+warp.length_sq(x: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec2ub) → uint8¶
+warp.length_sq(x: vec[3, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec3ub) → uint8¶
+warp.length_sq(x: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec4ub) → uint8¶
+warp.length_sq(x: vec[4, <class 'warp.types.float32'>]) → float32¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec2f) → float32¶
+warp.length_sq(x: vec[2, <class 'warp.types.uint8'>]) → uint8¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec2) → float32¶
+warp.length_sq(x: vec[3, <class 'warp.types.uint8'>]) → uint8¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec3f) → float32¶
+warp.length_sq(x: vec[4, <class 'warp.types.uint8'>]) → uint8¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec3) → float32¶
+warp.length_sq(x: vec[2, <class 'warp.types.float16'>]) → float16¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec4f) → float32¶
+warp.length_sq(x: vec[3, <class 'warp.types.float16'>]) → float16¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vec4) → float32¶
+warp.length_sq(x: vec[4, <class 'warp.types.float16'>]) → float16¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: vector_t) → Scalar¶
+warp.length_sq(x: vec[Any, Scalar]) → Scalar¶

Compute the squared length of a 2d vector.

-warp.length_sq(x: quath) → float16¶
+warp.length_sq(x: quaternion[<class 'warp.types.float64'>]) → float64¶

Compute the squared length of a quaternion.

-warp.length_sq(x: quatd) → float64¶
+warp.length_sq(x: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the squared length of a quaternion.

-warp.length_sq(x: quatf) → float32¶
+warp.length_sq(x: quaternion[<class 'warp.types.float32'>]) → float32¶

Compute the squared length of a quaternion.

-warp.length_sq(x: quat) → float32¶
+warp.length_sq(x: quaternion[<class 'warp.types.float16'>]) → float16¶

Compute the squared length of a quaternion.

-warp.length_sq(x: vector_t) → Scalar¶
+warp.length_sq(x: quaternion[Scalar]) → Scalar¶

Compute the squared length of a quaternion.

-warp.normalize(x: vec2h) → vec2h¶
+warp.normalize(x: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec3h) → vec3h¶
+warp.normalize(x: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec4h) → vec4h¶
+warp.normalize(x: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec2d) → vec2d¶
+warp.normalize(x: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec3d) → vec3d¶
+warp.normalize(x: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec4d) → vec4d¶
+warp.normalize(x: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec2f) → vec2f¶
+warp.normalize(x: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec2) → vec2f¶
+warp.normalize(x: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec3f) → vec3f¶
+warp.normalize(x: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec3) → vec3f¶
+warp.normalize(x: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec4f) → vec4f¶
+warp.normalize(x: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vec4) → vec4f¶
+warp.normalize(x: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: vector_t) → vector_t¶
+warp.normalize(x: vec[Any, Float]) → vec[Any, Scalar]¶

Compute the normalized value of x, if length(x) is 0 then the zero vector is returned.

-warp.normalize(x: quath) → quath¶
+warp.normalize(x: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero quat is returned.

-warp.normalize(x: quatd) → quatd¶
+warp.normalize(x: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero quat is returned.

-warp.normalize(x: quatf) → quatf¶
+warp.normalize(x: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero quat is returned.

-warp.normalize(x: quat) → quatf¶
+warp.normalize(x: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶

Compute the normalized value of x, if length(x) is 0 then the zero quat is returned.

-warp.normalize(x: vector_t) → vector_t¶
+warp.normalize(x: quaternion[Float]) → quaternion[Scalar]¶

Compute the normalized value of x, if length(x) is 0 then the zero quat is returned.

-warp.transpose(m: mat22h) → mat22h¶
+warp.transpose(m: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat33h) → mat33h¶
+warp.transpose(m: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat44h) → mat44h¶
+warp.transpose(m: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat22d) → mat22d¶
+warp.transpose(m: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat33d) → mat33d¶
+warp.transpose(m: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat44d) → mat44d¶
+warp.transpose(m: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat22f) → mat22f¶
+warp.transpose(m: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat22) → mat22f¶
+warp.transpose(m: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat33f) → mat33f¶
+warp.transpose(m: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat33) → mat33f¶
+warp.transpose(m: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat44f) → mat44f¶
+warp.transpose(m: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Return the transpose of the matrix m

-warp.transpose(m: mat44) → mat44f¶
+warp.transpose(m: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Return the transpose of the matrix m

-warp.transpose(m: matrix_t)¶
+warp.transpose(m: mat[Any, Any, Scalar])¶

Return the transpose of the matrix m

-warp.transpose(m: spatial_matrixh) → spatial_matrixh¶
+warp.transpose(m: spatial_matrix_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶

Return the transpose of the matrix m

-warp.transpose(m: spatial_matrixd) → spatial_matrixd¶
+warp.transpose(m: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: spatial_matrixf) → spatial_matrixf¶
+warp.transpose(m: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Return the transpose of the matrix m

-warp.transpose(m: spatial_matrix) → spatial_matrixf¶
+warp.transpose(m: spatial_matrix_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶

Return the transpose of the matrix m

-warp.transpose(m: matrix_t) → matrix_t¶
+warp.transpose(m: spatial_matrix_t[Scalar]) → spatial_matrix_t[Scalar]¶

Return the transpose of the matrix m

-warp.inverse(m: mat22h) → mat22h¶
+warp.inverse(m: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat33h) → mat33h¶
+warp.inverse(m: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat44h) → mat44h¶
+warp.inverse(m: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat22d) → mat22d¶
+warp.inverse(m: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat33d) → mat33d¶
+warp.inverse(m: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat44d) → mat44d¶
+warp.inverse(m: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat22f) → mat22f¶
+warp.inverse(m: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat22) → mat22f¶
+warp.inverse(m: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat33f) → mat33f¶
+warp.inverse(m: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat33) → mat33f¶
+warp.inverse(m: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat44f) → mat44f¶
+warp.inverse(m: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Return the inverse of the matrix m

-warp.inverse(m: mat44) → mat44f¶
+warp.inverse(m: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Return the inverse of the matrix m

-warp.inverse(m: matrix_t) → matrix_t¶
+warp.inverse(m: mat[Any, Any, Float]) → mat[Any, Any, Float]¶

Return the inverse of the matrix m

-warp.determinant(m: mat22h) → float16¶
+warp.determinant(m: mat[2, 2, <class 'warp.types.float64'>]) → float64¶

Return the determinant of the matrix m

-warp.determinant(m: mat33h) → float16¶
+warp.determinant(m: mat[3, 3, <class 'warp.types.float64'>]) → float64¶

Return the determinant of the matrix m

-warp.determinant(m: mat44h) → float16¶
+warp.determinant(m: mat[4, 4, <class 'warp.types.float64'>]) → float64¶

Return the determinant of the matrix m

-warp.determinant(m: mat22d) → float64¶
+warp.determinant(m: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat33d) → float64¶
+warp.determinant(m: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat44d) → float64¶
+warp.determinant(m: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat22f) → float32¶
+warp.determinant(m: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat22) → float32¶
+warp.determinant(m: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat33f) → float32¶
+warp.determinant(m: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Return the determinant of the matrix m

-warp.determinant(m: mat33) → float32¶
+warp.determinant(m: mat[2, 2, <class 'warp.types.float16'>]) → float16¶

Return the determinant of the matrix m

-warp.determinant(m: mat44f) → float32¶
+warp.determinant(m: mat[3, 3, <class 'warp.types.float16'>]) → float16¶

Return the determinant of the matrix m

-warp.determinant(m: mat44) → float32¶
+warp.determinant(m: mat[4, 4, <class 'warp.types.float16'>]) → float16¶

Return the determinant of the matrix m

-warp.determinant(m: matrix_t) → Scalar¶
+warp.determinant(m: mat[Any, Any, Scalar]) → Scalar¶

Return the determinant of the matrix m

-warp.trace(m: mat22h) → float16¶
+warp.trace(m: mat[2, 2, <class 'warp.types.float64'>]) → float64¶

Return the trace of the matrix m

-warp.trace(m: mat33h) → float16¶
+warp.trace(m: mat[3, 3, <class 'warp.types.float64'>]) → float64¶

Return the trace of the matrix m

-warp.trace(m: mat44h) → float16¶
+warp.trace(m: mat[4, 4, <class 'warp.types.float64'>]) → float64¶

Return the trace of the matrix m

-warp.trace(m: mat22d) → float64¶
+warp.trace(m: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat33d) → float64¶
+warp.trace(m: mat[2, 2, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat44d) → float64¶
+warp.trace(m: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat22f) → float32¶
+warp.trace(m: mat[3, 3, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat22) → float32¶
+warp.trace(m: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat33f) → float32¶
+warp.trace(m: mat[4, 4, <class 'warp.types.float32'>]) → float32¶

Return the trace of the matrix m

-warp.trace(m: mat33) → float32¶
+warp.trace(m: mat[2, 2, <class 'warp.types.float16'>]) → float16¶

Return the trace of the matrix m

-warp.trace(m: mat44f) → float32¶
+warp.trace(m: mat[3, 3, <class 'warp.types.float16'>]) → float16¶

Return the trace of the matrix m

-warp.trace(m: mat44) → float32¶
+warp.trace(m: mat[4, 4, <class 'warp.types.float16'>]) → float16¶

Return the trace of the matrix m

-warp.trace(m: matrix_t) → Scalar¶
+warp.trace(m: mat[Any, Any, Scalar]) → Scalar¶

Return the trace of the matrix m

-warp.diag(d: vec2h) → mat22h¶
+warp.diag(d: vec[2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec3h) → mat33h¶
+warp.diag(d: vec[3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec4h) → mat44h¶
+warp.diag(d: vec[4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec2d) → mat22d¶
+warp.diag(d: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec3d) → mat33d¶
+warp.diag(d: vec[2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec4d) → mat44d¶
+warp.diag(d: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec2f) → mat22f¶
+warp.diag(d: vec[3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec2) → mat22f¶
+warp.diag(d: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec3f) → mat33f¶
+warp.diag(d: vec[4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec3) → mat33f¶
+warp.diag(d: vec[2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec4f) → mat44f¶
+warp.diag(d: vec[3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vec4) → mat44f¶
+warp.diag(d: vec[4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Returns a matrix with the components of the vector d on the diagonal

-warp.diag(d: vector_t)¶
+warp.diag(d: vec[Any, Scalar])¶

Returns a matrix with the components of the vector d on the diagonal

-warp.cw_mul(x: vec2h, y: vec2h) → vec2h¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3h, y: vec3h) → vec3h¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4h, y: vec4h) → vec4h¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2d, y: vec2d) → vec2d¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3d, y: vec3d) → vec3d¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4d, y: vec4d) → vec4d¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2f, y: vec2f) → vec2f¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2f, y: vec2) → vec2f¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2, y: vec2f) → vec2f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec2, y: vec2) → vec2f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3f, y: vec3f) → vec3f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3f, y: vec3) → vec3f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3, y: vec3f) → vec3f¶
+warp.cw_mul(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec3, y: vec3) → vec3f¶
+warp.cw_mul(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4f, y: vec4f) → vec4f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4f, y: vec4) → vec4f¶
+warp.cw_mul(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4, y: vec4f) → vec4f¶
+warp.cw_mul(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vec4, y: vec4) → vec4f¶
+warp.cw_mul(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: vector_t, y: vector_t) → vector_t¶
+warp.cw_mul(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22h, y: mat22h) → mat22h¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33h, y: mat33h) → mat33h¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44h, y: mat44h) → mat44h¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22d, y: mat22d) → mat22d¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33d, y: mat33d) → mat33d¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44d, y: mat44d) → mat44d¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22f, y: mat22f) → mat22f¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22f, y: mat22) → mat22f¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22, y: mat22f) → mat22f¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat22, y: mat22) → mat22f¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33f, y: mat33f) → mat33f¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33f, y: mat33) → mat33f¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33, y: mat33f) → mat33f¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat33, y: mat33) → mat33f¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44f, y: mat44f) → mat44f¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44f, y: mat44) → mat44f¶
+warp.cw_mul(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44, y: mat44f) → mat44f¶
+warp.cw_mul(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: mat44, y: mat44) → mat44f¶
+warp.cw_mul(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Component wise multiply of two 2d vectors.

-warp.cw_mul(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.cw_mul(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶

Component wise multiply of two 2d vectors.

-warp.cw_div(x: vec2h, y: vec2h) → vec2h¶
+warp.cw_div(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3h, y: vec3h) → vec3h¶
+warp.cw_div(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4h, y: vec4h) → vec4h¶
+warp.cw_div(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2d, y: vec2d) → vec2d¶
+warp.cw_div(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3d, y: vec3d) → vec3d¶
+warp.cw_div(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4d, y: vec4d) → vec4d¶
+warp.cw_div(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.cw_div(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.cw_div(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.cw_div(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2f, y: vec2f) → vec2f¶
+warp.cw_div(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2f, y: vec2) → vec2f¶
+warp.cw_div(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2, y: vec2f) → vec2f¶
+warp.cw_div(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec2, y: vec2) → vec2f¶
+warp.cw_div(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3f, y: vec3f) → vec3f¶
+warp.cw_div(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3f, y: vec3) → vec3f¶
+warp.cw_div(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3, y: vec3f) → vec3f¶
+warp.cw_div(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec3, y: vec3) → vec3f¶
+warp.cw_div(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4f, y: vec4f) → vec4f¶
+warp.cw_div(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4f, y: vec4) → vec4f¶
+warp.cw_div(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4, y: vec4f) → vec4f¶
+warp.cw_div(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vec4, y: vec4) → vec4f¶
+warp.cw_div(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: vector_t, y: vector_t) → vector_t¶
+warp.cw_div(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22h, y: mat22h) → mat22h¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33h, y: mat33h) → mat33h¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44h, y: mat44h) → mat44h¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22d, y: mat22d) → mat22d¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33d, y: mat33d) → mat33d¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44d, y: mat44d) → mat44d¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22f, y: mat22f) → mat22f¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22f, y: mat22) → mat22f¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22, y: mat22f) → mat22f¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat22, y: mat22) → mat22f¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33f, y: mat33f) → mat33f¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33f, y: mat33) → mat33f¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33, y: mat33f) → mat33f¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat33, y: mat33) → mat33f¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44f, y: mat44f) → mat44f¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44f, y: mat44) → mat44f¶
+warp.cw_div(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44, y: mat44f) → mat44f¶
+warp.cw_div(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: mat44, y: mat44) → mat44f¶
+warp.cw_div(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶

Component wise division of two 2d vectors.

-warp.cw_div(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.cw_div(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶

Component wise division of two 2d vectors.

-warp.vec() → vector_t¶
+warp.vec() → vec[Any, Scalar]¶

Construct a zero-initialized vector.

-warp.vec(s: Scalar) → vector_t¶
+warp.vec(s: Scalar) → vec[Any, Scalar]¶

Construct a vector with all components set to s.

-warp.vec() → vector_t¶
+warp.vec() → vec[Any, Scalar]¶

Construct a vector from scalar compontents.

-warp.mat() → matrix_t¶
+warp.mat() → mat[Any, Any, Scalar]¶

Construct a zero matrix

-warp.mat(s: Scalar) → matrix_t¶
+warp.mat(s: Scalar) → mat[Any, Any, Scalar]¶

Construct a matrix with all components set to s

-warp.mat(pos: vector_t, rot: vector_t, scale: vector_t) → matrix_t¶
+warp.mat(pos: vec[3, Float], rot: quaternion[Float], scale: vec[3, Float]) → mat[Any, Any, 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.mat() → matrix_t¶
+warp.mat() → mat[Any, Any, Scalar]¶

Construct a matrix from components or column vectors.

-warp.svd3(A: mat33h, U: mat33h, sigma: vec3h, V: mat33h) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float64'>], U: mat[3, 3, <class 'warp.types.float64'>], sigma: vec[3, <class 'warp.types.float64'>], V: mat[3, 3, <class 'warp.types.float64'>]) → None¶

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

-warp.svd3(A: mat33d, U: mat33d, sigma: vec3d, V: mat33d) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float16'>], U: mat[3, 3, <class 'warp.types.float16'>], sigma: vec[3, <class 'warp.types.float16'>], V: mat[3, 3, <class 'warp.types.float16'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33, sigma: vec3, V: mat33f) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: mat33, U: mat33, sigma: vec3, V: mat33) → None¶
+warp.svd3(A: mat[3, 3, <class 'warp.types.float32'>], U: mat[3, 3, <class 'warp.types.float32'>], sigma: vec[3, <class 'warp.types.float32'>], V: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.svd3(A: matrix_t, U: matrix_t, sigma: vector_t, V: matrix_t) → None¶
+warp.svd3(A: mat[3, 3, Float], U: mat[3, 3, Float], sigma: vec[3, Float], V: mat[3, 3, Scalar]) → None¶

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

-warp.qr3(A: mat33h, Q: mat33h, R: mat33h) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float64'>], Q: mat[3, 3, <class 'warp.types.float64'>], R: mat[3, 3, <class 'warp.types.float64'>]) → None¶

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

-warp.qr3(A: mat33d, Q: mat33d, R: mat33d) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33f, Q: mat33f, R: mat33f) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33f, Q: mat33f, R: mat33) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33f, Q: mat33, R: mat33f) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33f, Q: mat33, R: mat33) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33, Q: mat33f, R: mat33f) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33, Q: mat33f, R: mat33) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33, Q: mat33, R: mat33f) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], R: mat[3, 3, <class 'warp.types.float32'>]) → None¶

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

-warp.qr3(A: mat33, Q: mat33, R: mat33) → None¶
+warp.qr3(A: mat[3, 3, <class 'warp.types.float16'>], Q: mat[3, 3, <class 'warp.types.float16'>], R: mat[3, 3, <class 'warp.types.float16'>]) → None¶

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

-warp.qr3(A: matrix_t, Q: matrix_t, R: matrix_t) → None¶
+warp.qr3(A: mat[3, 3, Float], Q: mat[3, 3, Float], R: mat[3, 3, Float]) → None¶

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

-warp.eig3(A: mat33h, Q: mat33h, d: vec3h) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float64'>], Q: mat[3, 3, <class 'warp.types.float64'>], d: vec[3, <class 'warp.types.float64'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33d, Q: mat33d, d: vec3d) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float16'>], Q: mat[3, 3, <class 'warp.types.float16'>], d: vec[3, <class 'warp.types.float16'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33f, Q: mat33f, d: vec3f) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33f, Q: mat33f, d: vec3) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33f, Q: mat33, d: vec3f) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33f, Q: mat33, d: vec3) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33, Q: mat33f, d: vec3f) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33, Q: mat33f, d: vec3) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33, Q: mat33, d: vec3f) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: mat33, Q: mat33, d: vec3) → None¶
+warp.eig3(A: mat[3, 3, <class 'warp.types.float32'>], Q: mat[3, 3, <class 'warp.types.float32'>], d: vec[3, <class 'warp.types.float32'>]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

-warp.eig3(A: matrix_t, Q: matrix_t, d: vector_t) → None¶
+warp.eig3(A: mat[3, 3, Float], Q: mat[3, 3, Float], d: vec[3, Float]) → None¶

Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d.

@@ -3867,338 +3867,338 @@

Vector Math¶

-warp.quaternion() → vector_t¶
+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) → vector_t¶
+warp.quaternion(x: Float, y: Float, z: Float, w: Float) → quaternion[Float]¶

Construct a quarternion from its components x, y, z are the imaginary parts, w is the real part.

-warp.quaternion(i: vector_t, r: Float) → vector_t¶
+warp.quaternion(i: vec[3, Float], r: Float) → quaternion[Float]¶

Construct a quaternion from it’s imaginary components i, and real part r

-warp.quat_identity() → quat¶
+warp.quat_identity() → quaternion[<class 'warp.types.float32'>]¶

Construct a float32 identity quaternion with zero imaginary part and real part of 1.0

-warp.quat_from_axis_angle(axis: vec3h, angle: float16) → quath¶
+warp.quat_from_axis_angle(axis: vec[3, <class 'warp.types.float64'>], angle: float64) → quaternion[<class 'warp.types.float64'>]¶

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

-warp.quat_from_axis_angle(axis: vec3d, angle: float64) → quatd¶
+warp.quat_from_axis_angle(axis: vec[3, <class 'warp.types.float16'>], angle: float16) → quaternion[<class 'warp.types.float16'>]¶

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

-warp.quat_from_axis_angle(axis: vec3f, angle: float32) → quatf¶
+warp.quat_from_axis_angle(axis: vec[3, <class 'warp.types.float32'>], angle: float32) → quaternion[<class 'warp.types.float32'>]¶

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

-warp.quat_from_axis_angle(axis: vec3, angle: float32) → quatf¶
+warp.quat_from_axis_angle(axis: vec[3, <class 'warp.types.float32'>], angle: float32) → quaternion[<class 'warp.types.float32'>]¶

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

-warp.quat_from_axis_angle(axis: vector_t, angle: Float) → vector_t¶
+warp.quat_from_axis_angle(axis: vec[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: quath, axis: vec3h, angle: float16) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float64'>], axis: vec[3, <class 'warp.types.float64'>], angle: float64) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: quatd, axis: vec3d, angle: float64) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float32'>], axis: vec[3, <class 'warp.types.float32'>], angle: float32) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: quatf, axis: vec3f, angle: float32) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float32'>], axis: vec[3, <class 'warp.types.float32'>], angle: float32) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: quatf, axis: vec3, angle: float32) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float32'>], axis: vec[3, <class 'warp.types.float32'>], angle: float32) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: quat, axis: vec3f, angle: float32) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float32'>], axis: vec[3, <class 'warp.types.float32'>], angle: float32) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: quat, axis: vec3, angle: float32) → None¶
+warp.quat_to_axis_angle(q: quaternion[<class 'warp.types.float16'>], axis: vec[3, <class 'warp.types.float16'>], angle: float16) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_to_axis_angle(q: vector_t, axis: vector_t, angle: Float) → None¶
+warp.quat_to_axis_angle(q: quaternion[Float], axis: vec[3, Float], angle: Float) → None¶

Extract the rotation axis and angle radians a quaternion represents.

-warp.quat_from_matrix(m: mat33h) → quath¶
+warp.quat_from_matrix(m: mat[3, 3, <class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶

Construct a quaternion from a 3x3 matrix.

-warp.quat_from_matrix(m: mat33d) → quatd¶
+warp.quat_from_matrix(m: mat[3, 3, <class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Construct a quaternion from a 3x3 matrix.

-warp.quat_from_matrix(m: mat33f) → quatf¶
+warp.quat_from_matrix(m: mat[3, 3, <class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Construct a quaternion from a 3x3 matrix.

-warp.quat_from_matrix(m: mat33) → quatf¶
+warp.quat_from_matrix(m: mat[3, 3, <class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶

Construct a quaternion from a 3x3 matrix.

-warp.quat_from_matrix(m: matrix_t) → vector_t¶
+warp.quat_from_matrix(m: mat[3, 3, Float]) → quaternion[Scalar]¶

Construct a quaternion from a 3x3 matrix.

-warp.quat_rpy(roll: float16, pitch: float16, yaw: float16) → quath¶
+warp.quat_rpy(roll: float64, pitch: float64, yaw: float64) → quaternion[<class 'warp.types.float64'>]¶

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

-warp.quat_rpy(roll: float64, pitch: float64, yaw: float64) → quatd¶
+warp.quat_rpy(roll: float32, pitch: float32, yaw: float32) → quaternion[<class 'warp.types.float32'>]¶

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

-warp.quat_rpy(roll: float32, pitch: float32, yaw: float32) → quatf¶
+warp.quat_rpy(roll: float16, pitch: float16, yaw: float16) → quaternion[<class 'warp.types.float16'>]¶

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

-warp.quat_rpy(roll: Float, pitch: Float, yaw: Float) → vector_t¶
+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: quath) → quath¶
+warp.quat_inverse(q: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶

Compute quaternion conjugate.

-warp.quat_inverse(q: quatd) → quatd¶
+warp.quat_inverse(q: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Compute quaternion conjugate.

-warp.quat_inverse(q: quatf) → quatf¶
+warp.quat_inverse(q: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Compute quaternion conjugate.

-warp.quat_inverse(q: quat) → quatf¶
+warp.quat_inverse(q: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶

Compute quaternion conjugate.

-warp.quat_inverse(q: vector_t) → vector_t¶
+warp.quat_inverse(q: quaternion[Float]) → quaternion[Scalar]¶

Compute quaternion conjugate.

-warp.quat_rotate(q: quath, p: vec3h) → vec3h¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float64'>], p: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: quatd, p: vec3d) → vec3d¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float16'>], p: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: quatf, p: vec3f) → vec3f¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: quatf, p: vec3) → vec3f¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: quat, p: vec3f) → vec3f¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: quat, p: vec3) → vec3f¶
+warp.quat_rotate(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector by a quaternion.

-warp.quat_rotate(q: vector_t, p: vector_t) → vector_t¶
+warp.quat_rotate(q: quaternion[Float], p: vec[3, Float]) → vec[3, Scalar]¶

Rotate a vector by a quaternion.

-warp.quat_rotate_inv(q: quath, p: vec3h) → vec3h¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float64'>], p: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: quatd, p: vec3d) → vec3d¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float16'>], p: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: quatf, p: vec3f) → vec3f¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: quatf, p: vec3) → vec3f¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: quat, p: vec3f) → vec3f¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: quat, p: vec3) → vec3f¶
+warp.quat_rotate_inv(q: quaternion[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_rotate_inv(q: vector_t, p: vector_t) → vector_t¶
+warp.quat_rotate_inv(q: quaternion[Float], p: vec[3, Float]) → vec[3, Scalar]¶

Rotate a vector the inverse of a quaternion.

-warp.quat_slerp(q0: quath, q1: quath, t: float16) → quath¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float64'>], q1: quaternion[<class 'warp.types.float64'>], t: float64) → quaternion[<class 'warp.types.float64'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: quatd, q1: quatd, t: float64) → quatd¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float16'>], q1: quaternion[<class 'warp.types.float16'>], t: float16) → quaternion[<class 'warp.types.float16'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: quatf, q1: quatf, t: float32) → quatf¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float32'>], q1: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: quatf, q1: quat, t: float32) → quatf¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float32'>], q1: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: quat, q1: quatf, t: float32) → quatf¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float32'>], q1: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: quat, q1: quat, t: float32) → quatf¶
+warp.quat_slerp(q0: quaternion[<class 'warp.types.float32'>], q1: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate between two quaternions.

-warp.quat_slerp(q0: vector_t, q1: vector_t, t: Float) → vector_t¶
+warp.quat_slerp(q0: quaternion[Float], q1: quaternion[Float], t: Float) → quaternion[Scalar]¶

Linearly interpolate between two quaternions.

-warp.quat_to_matrix(q: quath) → mat33h¶
+warp.quat_to_matrix(q: quaternion[<class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶

Convert a quaternion to a 3x3 rotation matrix.

-warp.quat_to_matrix(q: quatd) → mat33d¶
+warp.quat_to_matrix(q: quaternion[<class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Convert a quaternion to a 3x3 rotation matrix.

-warp.quat_to_matrix(q: quatf) → mat33f¶
+warp.quat_to_matrix(q: quaternion[<class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶

Convert a quaternion to a 3x3 rotation matrix.

-warp.quat_to_matrix(q: quat) → mat33f¶
+warp.quat_to_matrix(q: quaternion[<class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶

Convert a quaternion to a 3x3 rotation matrix.

-warp.quat_to_matrix(q: vector_t) → matrix_t¶
+warp.quat_to_matrix(q: quaternion[Float]) → mat[3, 3, Scalar]¶

Convert a quaternion to a 3x3 rotation matrix.

@@ -4207,163 +4207,163 @@

Quaternion Math¶

-warp.transform_t(p: vector_t, q: vector_t) → transform_class¶
+warp.transform_t(p: vec[3, Float], q: quaternion[Float]) → transform_t[Scalar]¶

Construct a rigid body transformation with translation part p and rotation q.

-warp.transform_identity() → transform¶
+warp.transform_identity() → transform_t[<class 'warp.types.float32'>]¶

Construct a float32 identity transform with zero translation and identity rotation.

-warp.transform_get_translation(t: transformh) → vec3h¶
+warp.transform_get_translation(t: transform_t[<class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

Return the translational part of a transform.

-warp.transform_get_translation(t: transformd) → vec3d¶
+warp.transform_get_translation(t: transform_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the translational part of a transform.

-warp.transform_get_translation(t: transformf) → vec3f¶
+warp.transform_get_translation(t: transform_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Return the translational part of a transform.

-warp.transform_get_translation(t: transform) → vec3f¶
+warp.transform_get_translation(t: transform_t[<class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

Return the translational part of a transform.

-warp.transform_get_translation(t: transform_class) → vector_t¶
+warp.transform_get_translation(t: transform_t[Float]) → vec[3, Scalar]¶

Return the translational part of a transform.

-warp.transform_get_rotation(t: transformh) → quath¶
+warp.transform_get_rotation(t: transform_t[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶

Return the rotational part of a transform.

-warp.transform_get_rotation(t: transformd) → quatd¶
+warp.transform_get_rotation(t: transform_t[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Return the rotational part of a transform.

-warp.transform_get_rotation(t: transformf) → quatf¶
+warp.transform_get_rotation(t: transform_t[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶

Return the rotational part of a transform.

-warp.transform_get_rotation(t: transform) → quatf¶
+warp.transform_get_rotation(t: transform_t[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶

Return the rotational part of a transform.

-warp.transform_get_rotation(t: transform_class) → vector_t¶
+warp.transform_get_rotation(t: transform_t[Float]) → quaternion[Scalar]¶

Return the rotational part of a transform.

-warp.transform_multiply(a: transformh, b: transformh) → transformh¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float64'>], b: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transformd, b: transformd) → transformd¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transformf, b: transformf) → transformf¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transformf, b: transform) → transformf¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transform, b: transformf) → transformf¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transform, b: transform) → transformf¶
+warp.transform_multiply(a: transform_t[<class 'warp.types.float16'>], b: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶

Multiply two rigid body transformations together.

-warp.transform_multiply(a: transform_class, b: transform_class) → transform_class¶
+warp.transform_multiply(a: transform_t[Float], b: transform_t[Float]) → transform_t[Scalar]¶

Multiply two rigid body transformations together.

-warp.transform_point(t: transformh, p: vec3h) → vec3h¶
+warp.transform_point(t: transform_t[<class 'warp.types.float64'>], p: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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

-warp.transform_point(t: transformd, p: vec3d) → vec3d¶
+warp.transform_point(t: transform_t[<class 'warp.types.float16'>], p: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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

-warp.transform_point(t: transformf, p: vec3f) → vec3f¶
+warp.transform_point(t: transform_t[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_point(t: transformf, p: vec3) → vec3f¶
+warp.transform_point(t: transform_t[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_point(t: transform, p: vec3f) → vec3f¶
+warp.transform_point(t: transform_t[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_point(t: transform, p: vec3) → vec3f¶
+warp.transform_point(t: transform_t[<class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_point(t: transform_class, p: vector_t) → vector_t¶
+warp.transform_point(t: transform_t[Scalar], p: vec[3, Scalar]) → vec[3, Scalar]¶

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

-warp.transform_point(m: mat44h, p: vec3h) → vec3h¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float64'>], p: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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 tranformation matrix before calling this method.

@@ -4371,7 +4371,7 @@

Transformations
-warp.transform_point(m: mat44d, p: vec3d) → vec3d¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float16'>], p: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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 tranformation matrix before calling this method.

@@ -4379,7 +4379,7 @@

Transformations
-warp.transform_point(m: mat44f, p: vec3f) → vec3f¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4387,7 +4387,7 @@

Transformations
-warp.transform_point(m: mat44f, p: vec3) → vec3f¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4395,7 +4395,7 @@

Transformations
-warp.transform_point(m: mat44, p: vec3f) → vec3f¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4403,7 +4403,7 @@

Transformations
-warp.transform_point(m: mat44, p: vec3) → vec3f¶
+warp.transform_point(m: mat[4, 4, <class 'warp.types.float32'>], p: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4411,7 +4411,7 @@

Transformations
-warp.transform_point(m: matrix_t, p: vector_t) → vector_t¶
+warp.transform_point(m: mat[4, 4, Scalar], p: vec[3, Scalar]) → vec[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 tranformation matrix before calling this method.

@@ -4419,49 +4419,49 @@

Transformations
-warp.transform_vector(t: transformh, v: vec3h) → vec3h¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float64'>], v: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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

-warp.transform_vector(t: transformd, v: vec3d) → vec3d¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float16'>], v: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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

-warp.transform_vector(t: transformf, v: vec3f) → vec3f¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_vector(t: transformf, v: vec3) → vec3f¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_vector(t: transform, v: vec3f) → vec3f¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_vector(t: transform, v: vec3) → vec3f¶
+warp.transform_vector(t: transform_t[<class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.transform_vector(t: transform_class, v: vector_t) → vector_t¶
+warp.transform_vector(t: transform_t[Scalar], v: vec[3, Scalar]) → vec[3, Scalar]¶

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

-warp.transform_vector(m: mat44h, v: vec3h) → vec3h¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float64'>], v: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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 tranformation matrix before calling this method.

@@ -4469,7 +4469,7 @@

Transformations
-warp.transform_vector(m: mat44d, v: vec3d) → vec3d¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float16'>], v: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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 tranformation matrix before calling this method.

@@ -4477,7 +4477,7 @@

Transformations
-warp.transform_vector(m: mat44f, v: vec3f) → vec3f¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4485,7 +4485,7 @@

Transformations
-warp.transform_vector(m: mat44f, v: vec3) → vec3f¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4493,7 +4493,7 @@

Transformations
-warp.transform_vector(m: mat44, v: vec3f) → vec3f¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4501,7 +4501,7 @@

Transformations
-warp.transform_vector(m: mat44, v: vec3) → vec3f¶
+warp.transform_vector(m: mat[4, 4, <class 'warp.types.float32'>], v: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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 tranformation matrix before calling this method.

@@ -4509,7 +4509,7 @@

Transformations
-warp.transform_vector(m: matrix_t, v: vector_t) → vector_t¶
+warp.transform_vector(m: mat[4, 4, Scalar], v: vec[3, Scalar]) → vec[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 tranformation matrix before calling this method.

@@ -4517,31 +4517,31 @@

Transformations
-warp.transform_inverse(t: transformh) → transformh¶
+warp.transform_inverse(t: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶

Compute the inverse of the transform.

-warp.transform_inverse(t: transformd) → transformd¶
+warp.transform_inverse(t: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Compute the inverse of the transform.

-warp.transform_inverse(t: transformf) → transformf¶
+warp.transform_inverse(t: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶

Compute the inverse of the transform.

-warp.transform_inverse(t: transform) → transformf¶
+warp.transform_inverse(t: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶

Compute the inverse of the transform.

-warp.transform_inverse(t: transform_class) → transform_class¶
+warp.transform_inverse(t: transform_t[Float]) → transform_t[Float]¶

Compute the inverse of the transform.

@@ -4550,240 +4550,240 @@

Transformations¶

-warp.spatial_vector_t() → vector_t¶
+warp.spatial_vector_t() → spatial_vector_t[Float]¶

Construct a zero-initialized 6d screw vector. Screw vectors may be used to represent rigid body wrenches and twists (velocites).

-warp.spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) → vector_t¶
+warp.spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) → spatial_vector_t[Float]¶

Construct a 6d screw vector from it’s components.

-warp.spatial_vector_t(w: vector_t, v: vector_t) → vector_t¶
+warp.spatial_vector_t(w: vec[3, Float], v: vec[3, Float]) → spatial_vector_t[Float]¶

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

-warp.spatial_vector_t(s: Float) → vector_t¶
+warp.spatial_vector_t(s: Float) → spatial_vector_t[Float]¶

Construct a 6d screw vector with all components set to s

-warp.spatial_matrix_t() → matrix_t¶
+warp.spatial_matrix_t() → spatial_matrix_t[Float]¶

Construct a 6x6 zero-initialized spatial inertia matrix

-warp.spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) → matrix_t¶
+warp.spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) → spatial_matrix_t[Float]¶

Construct a 6x6 spatial inertia matrix from components

-warp.spatial_adjoint(r: matrix_t, s: matrix_t) → matrix_t¶
+warp.spatial_adjoint(r: mat[3, 3, Float], s: mat[3, 3, Float]) → spatial_matrix_t[Scalar]¶

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

-warp.spatial_dot(a: spatial_vectorh, b: spatial_vectorh) → float16¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float64'>], b: spatial_vector_t[<class 'warp.types.float64'>]) → float64¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: spatial_vectord, b: spatial_vectord) → float64¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → float32¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: spatial_vectorf, b: spatial_vectorf) → float32¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → float32¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: spatial_vectorf, b: spatial_vector) → float32¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → float32¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: spatial_vector, b: spatial_vectorf) → float32¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → float32¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: spatial_vector, b: spatial_vector) → float32¶
+warp.spatial_dot(a: spatial_vector_t[<class 'warp.types.float16'>], b: spatial_vector_t[<class 'warp.types.float16'>]) → float16¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_dot(a: vector_t, b: vector_t) → Scalar¶
+warp.spatial_dot(a: spatial_vector_t[Float], b: spatial_vector_t[Float]) → Scalar¶

Compute the dot product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vectorh, b: spatial_vectorh) → spatial_vectorh¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float64'>], b: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vectord, b: spatial_vectord) → spatial_vectord¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vectorf, b: spatial_vectorf) → spatial_vectorf¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vectorf, b: spatial_vector) → spatial_vectorf¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vector, b: spatial_vectorf) → spatial_vectorf¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: spatial_vector, b: spatial_vector) → spatial_vectorf¶
+warp.spatial_cross(a: spatial_vector_t[<class 'warp.types.float16'>], b: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross(a: vector_t, b: vector_t) → vector_t¶
+warp.spatial_cross(a: spatial_vector_t[Float], b: spatial_vector_t[Float]) → spatial_vector_t[Float]¶

Compute the cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vectorh, b: spatial_vectorh) → spatial_vectorh¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float64'>], b: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vectord, b: spatial_vectord) → spatial_vectord¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vectorf, b: spatial_vectorf) → spatial_vectorf¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vectorf, b: spatial_vector) → spatial_vectorf¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vector, b: spatial_vectorf) → spatial_vectorf¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: spatial_vector, b: spatial_vector) → spatial_vectorf¶
+warp.spatial_cross_dual(a: spatial_vector_t[<class 'warp.types.float16'>], b: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_cross_dual(a: vector_t, b: vector_t) → vector_t¶
+warp.spatial_cross_dual(a: spatial_vector_t[Float], b: spatial_vector_t[Float]) → spatial_vector_t[Float]¶

Compute the dual cross-product of two 6d screw vectors.

-warp.spatial_top(a: spatial_vectorh) → vec3h¶
+warp.spatial_top(a: spatial_vector_t[<class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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

-warp.spatial_top(a: spatial_vectord) → vec3d¶
+warp.spatial_top(a: spatial_vector_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.spatial_top(a: spatial_vectorf) → vec3f¶
+warp.spatial_top(a: spatial_vector_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.spatial_top(a: spatial_vector) → vec3f¶
+warp.spatial_top(a: spatial_vector_t[<class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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

-warp.spatial_top(a: vector_t)¶
+warp.spatial_top(a: spatial_vector_t[Float])¶

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

-warp.spatial_bottom(a: spatial_vectorh) → vec3h¶
+warp.spatial_bottom(a: spatial_vector_t[<class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶

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

-warp.spatial_bottom(a: spatial_vectord) → vec3d¶
+warp.spatial_bottom(a: spatial_vector_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.spatial_bottom(a: spatial_vectorf) → vec3f¶
+warp.spatial_bottom(a: spatial_vector_t[<class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.spatial_bottom(a: spatial_vector) → vec3f¶
+warp.spatial_bottom(a: spatial_vector_t[<class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶

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

-warp.spatial_bottom(a: vector_t)¶
+warp.spatial_bottom(a: spatial_vector_t[Float])¶

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

-warp.spatial_jacobian(S: array[vector_t], 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_jacobian(S: array[spatial_vector_t[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_t], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) → None¶
+warp.spatial_mass(I_s: array[spatial_matrix_t[Float]], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) → None¶
@@ -5017,559 +5017,559 @@

Utility
-warp.expect_eq(arg1: quath, arg2: quath) → None¶
+warp.expect_eq(arg1: quaternion[<class 'warp.types.float16'>], arg2: quaternion[<class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: quatf, arg2: quatf) → None¶
+warp.expect_eq(arg1: quaternion[<class 'warp.types.float32'>], arg2: quaternion[<class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: quatd, arg2: quatd) → None¶
+warp.expect_eq(arg1: quaternion[<class 'warp.types.float64'>], arg2: quaternion[<class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: quat, arg2: quat) → None¶
+warp.expect_eq(arg1: quaternion[<class 'warp.types.float32'>], arg2: quaternion[<class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: transformh, arg2: transformh) → None¶
+warp.expect_eq(arg1: transform_t[<class 'warp.types.float16'>], arg2: transform_t[<class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: transformf, arg2: transformf) → None¶
+warp.expect_eq(arg1: transform_t[<class 'warp.types.float32'>], arg2: transform_t[<class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: transformd, arg2: transformd) → None¶
+warp.expect_eq(arg1: transform_t[<class 'warp.types.float64'>], arg2: transform_t[<class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: transform, arg2: transform) → None¶
+warp.expect_eq(arg1: transform_t[<class 'warp.types.float32'>], arg2: transform_t[<class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2h, arg2: vec2h) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float64'>], arg2: vec[2, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3h, arg2: vec3h) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float64'>], arg2: vec[3, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4h, arg2: vec4h) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float64'>], arg2: vec[4, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2d, arg2: vec2d) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3d, arg2: vec3d) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4d, arg2: vec4d) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2ub, arg2: vec2ub) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3ub, arg2: vec3ub) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4ub, arg2: vec4ub) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2f, arg2: vec2f) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2f, arg2: vec2) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2, arg2: vec2f) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec2, arg2: vec2) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3f, arg2: vec3f) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3f, arg2: vec3) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3, arg2: vec3f) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.uint8'>], arg2: vec[2, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec3, arg2: vec3) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.uint8'>], arg2: vec[3, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4f, arg2: vec4f) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.uint8'>], arg2: vec[4, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4f, arg2: vec4) → None¶
+warp.expect_eq(arg1: vec[2, <class 'warp.types.float16'>], arg2: vec[2, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4, arg2: vec4f) → None¶
+warp.expect_eq(arg1: vec[3, <class 'warp.types.float16'>], arg2: vec[3, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vec4, arg2: vec4) → None¶
+warp.expect_eq(arg1: vec[4, <class 'warp.types.float16'>], arg2: vec[4, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: vector_t, arg2: vector_t)¶
+warp.expect_eq(arg1: vec[Any, Scalar], arg2: vec[Any, Scalar])¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22h, arg2: mat22h) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float64'>], arg2: mat[2, 2, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33h, arg2: mat33h) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float64'>], arg2: mat[3, 3, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44h, arg2: mat44h) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float64'>], arg2: mat[4, 4, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22d, arg2: mat22d) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33d, arg2: mat33d) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44d, arg2: mat44d) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22f, arg2: mat22f) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22f, arg2: mat22) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22, arg2: mat22f) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat22, arg2: mat22) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33f, arg2: mat33f) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33f, arg2: mat33) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33, arg2: mat33f) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat33, arg2: mat33) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44f, arg2: mat44f) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44f, arg2: mat44) → None¶
+warp.expect_eq(arg1: mat[2, 2, <class 'warp.types.float16'>], arg2: mat[2, 2, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44, arg2: mat44f) → None¶
+warp.expect_eq(arg1: mat[3, 3, <class 'warp.types.float16'>], arg2: mat[3, 3, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: mat44, arg2: mat44) → None¶
+warp.expect_eq(arg1: mat[4, 4, <class 'warp.types.float16'>], arg2: mat[4, 4, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_eq(arg1: matrix_t, arg2: matrix_t)¶
+warp.expect_eq(arg1: mat[Any, Any, Scalar], arg2: mat[Any, Any, Scalar])¶

Prints an error to stdout if arg1 and arg2 are not equal

-warp.expect_neq(arg1: vec2h, arg2: vec2h) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float64'>], arg2: vec[2, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3h, arg2: vec3h) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float64'>], arg2: vec[3, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4h, arg2: vec4h) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float64'>], arg2: vec[4, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2d, arg2: vec2d) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3d, arg2: vec3d) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4d, arg2: vec4d) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2ub, arg2: vec2ub) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float32'>], arg2: vec[2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3ub, arg2: vec3ub) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4ub, arg2: vec4ub) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2f, arg2: vec2f) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2f, arg2: vec2) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2, arg2: vec2f) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec2, arg2: vec2) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3f, arg2: vec3f) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3f, arg2: vec3) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float32'>], arg2: vec[4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3, arg2: vec3f) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.uint8'>], arg2: vec[2, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec3, arg2: vec3) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.uint8'>], arg2: vec[3, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4f, arg2: vec4f) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.uint8'>], arg2: vec[4, <class 'warp.types.uint8'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4f, arg2: vec4) → None¶
+warp.expect_neq(arg1: vec[2, <class 'warp.types.float16'>], arg2: vec[2, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4, arg2: vec4f) → None¶
+warp.expect_neq(arg1: vec[3, <class 'warp.types.float16'>], arg2: vec[3, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vec4, arg2: vec4) → None¶
+warp.expect_neq(arg1: vec[4, <class 'warp.types.float16'>], arg2: vec[4, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: vector_t, arg2: vector_t)¶
+warp.expect_neq(arg1: vec[Any, Scalar], arg2: vec[Any, Scalar])¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22h, arg2: mat22h) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float64'>], arg2: mat[2, 2, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33h, arg2: mat33h) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float64'>], arg2: mat[3, 3, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44h, arg2: mat44h) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float64'>], arg2: mat[4, 4, <class 'warp.types.float64'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22d, arg2: mat22d) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33d, arg2: mat33d) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44d, arg2: mat44d) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22f, arg2: mat22f) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float32'>], arg2: mat[2, 2, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22f, arg2: mat22) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22, arg2: mat22f) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat22, arg2: mat22) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33f, arg2: mat33f) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float32'>], arg2: mat[3, 3, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33f, arg2: mat33) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33, arg2: mat33f) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat33, arg2: mat33) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44f, arg2: mat44f) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float32'>], arg2: mat[4, 4, <class 'warp.types.float32'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44f, arg2: mat44) → None¶
+warp.expect_neq(arg1: mat[2, 2, <class 'warp.types.float16'>], arg2: mat[2, 2, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44, arg2: mat44f) → None¶
+warp.expect_neq(arg1: mat[3, 3, <class 'warp.types.float16'>], arg2: mat[3, 3, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: mat44, arg2: mat44) → None¶
+warp.expect_neq(arg1: mat[4, 4, <class 'warp.types.float16'>], arg2: mat[4, 4, <class 'warp.types.float16'>]) → None¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.expect_neq(arg1: matrix_t, arg2: matrix_t)¶
+warp.expect_neq(arg1: mat[Any, Any, Scalar], arg2: mat[Any, Any, Scalar])¶

Prints an error to stdout if arg1 and arg2 are equal

-warp.lerp(a: float16, b: float16, t: float16) → float16¶
+warp.lerp(a: float64, b: float64, t: float64) → float64¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: float64, b: float64, t: float64) → float64¶
+warp.lerp(a: float32, b: float32, t: float32) → float32¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: float32, b: float32, t: float32) → float32¶
+warp.lerp(a: float16, b: float16, t: float16) → float16¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

@@ -5581,259 +5581,259 @@

Utility
-warp.lerp(a: vec2h, b: vec2h, t: float16) → vec2h¶
+warp.lerp(a: vec[2, <class 'warp.types.float16'>], b: vec[2, <class 'warp.types.float16'>], t: float16) → vec[2, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec2f, b: vec2f, t: float32) → vec2f¶
+warp.lerp(a: vec[2, <class 'warp.types.float32'>], b: vec[2, <class 'warp.types.float32'>], t: float32) → vec[2, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec2d, b: vec2d, t: float64) → vec2d¶
+warp.lerp(a: vec[2, <class 'warp.types.float64'>], b: vec[2, <class 'warp.types.float64'>], t: float64) → vec[2, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec2, b: vec2, t: float32) → vec2¶
+warp.lerp(a: vec[2, <class 'warp.types.float32'>], b: vec[2, <class 'warp.types.float32'>], t: float32) → vec[2, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec3h, b: vec3h, t: float16) → vec3h¶
+warp.lerp(a: vec[3, <class 'warp.types.float16'>], b: vec[3, <class 'warp.types.float16'>], t: float16) → vec[3, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec3f, b: vec3f, t: float32) → vec3f¶
+warp.lerp(a: vec[3, <class 'warp.types.float32'>], b: vec[3, <class 'warp.types.float32'>], t: float32) → vec[3, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec3d, b: vec3d, t: float64) → vec3d¶
+warp.lerp(a: vec[3, <class 'warp.types.float64'>], b: vec[3, <class 'warp.types.float64'>], t: float64) → vec[3, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec3, b: vec3, t: float32) → vec3¶
+warp.lerp(a: vec[3, <class 'warp.types.float32'>], b: vec[3, <class 'warp.types.float32'>], t: float32) → vec[3, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec4h, b: vec4h, t: float16) → vec4h¶
+warp.lerp(a: vec[4, <class 'warp.types.float16'>], b: vec[4, <class 'warp.types.float16'>], t: float16) → vec[4, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec4f, b: vec4f, t: float32) → vec4f¶
+warp.lerp(a: vec[4, <class 'warp.types.float32'>], b: vec[4, <class 'warp.types.float32'>], t: float32) → vec[4, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec4d, b: vec4d, t: float64) → vec4d¶
+warp.lerp(a: vec[4, <class 'warp.types.float64'>], b: vec[4, <class 'warp.types.float64'>], t: float64) → vec[4, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: vec4, b: vec4, t: float32) → vec4¶
+warp.lerp(a: vec[4, <class 'warp.types.float32'>], b: vec[4, <class 'warp.types.float32'>], t: float32) → vec[4, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat22h, b: mat22h, t: float16) → mat22h¶
+warp.lerp(a: mat[2, 2, <class 'warp.types.float16'>], b: mat[2, 2, <class 'warp.types.float16'>], t: float16) → mat[2, 2, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat22f, b: mat22f, t: float32) → mat22f¶
+warp.lerp(a: mat[2, 2, <class 'warp.types.float32'>], b: mat[2, 2, <class 'warp.types.float32'>], t: float32) → mat[2, 2, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat22d, b: mat22d, t: float64) → mat22d¶
+warp.lerp(a: mat[2, 2, <class 'warp.types.float64'>], b: mat[2, 2, <class 'warp.types.float64'>], t: float64) → mat[2, 2, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat22, b: mat22, t: float32) → mat22¶
+warp.lerp(a: mat[2, 2, <class 'warp.types.float32'>], b: mat[2, 2, <class 'warp.types.float32'>], t: float32) → mat[2, 2, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat33h, b: mat33h, t: float16) → mat33h¶
+warp.lerp(a: mat[3, 3, <class 'warp.types.float16'>], b: mat[3, 3, <class 'warp.types.float16'>], t: float16) → mat[3, 3, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat33f, b: mat33f, t: float32) → mat33f¶
+warp.lerp(a: mat[3, 3, <class 'warp.types.float32'>], b: mat[3, 3, <class 'warp.types.float32'>], t: float32) → mat[3, 3, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat33d, b: mat33d, t: float64) → mat33d¶
+warp.lerp(a: mat[3, 3, <class 'warp.types.float64'>], b: mat[3, 3, <class 'warp.types.float64'>], t: float64) → mat[3, 3, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat33, b: mat33, t: float32) → mat33¶
+warp.lerp(a: mat[3, 3, <class 'warp.types.float32'>], b: mat[3, 3, <class 'warp.types.float32'>], t: float32) → mat[3, 3, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat44h, b: mat44h, t: float16) → mat44h¶
+warp.lerp(a: mat[4, 4, <class 'warp.types.float16'>], b: mat[4, 4, <class 'warp.types.float16'>], t: float16) → mat[4, 4, <class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat44f, b: mat44f, t: float32) → mat44f¶
+warp.lerp(a: mat[4, 4, <class 'warp.types.float32'>], b: mat[4, 4, <class 'warp.types.float32'>], t: float32) → mat[4, 4, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat44d, b: mat44d, t: float64) → mat44d¶
+warp.lerp(a: mat[4, 4, <class 'warp.types.float64'>], b: mat[4, 4, <class 'warp.types.float64'>], t: float64) → mat[4, 4, <class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: mat44, b: mat44, t: float32) → mat44¶
+warp.lerp(a: mat[4, 4, <class 'warp.types.float32'>], b: mat[4, 4, <class 'warp.types.float32'>], t: float32) → mat[4, 4, <class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: quath, b: quath, t: float16) → quath¶
+warp.lerp(a: quaternion[<class 'warp.types.float16'>], b: quaternion[<class 'warp.types.float16'>], t: float16) → quaternion[<class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: quatf, b: quatf, t: float32) → quatf¶
+warp.lerp(a: quaternion[<class 'warp.types.float32'>], b: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: quatd, b: quatd, t: float64) → quatd¶
+warp.lerp(a: quaternion[<class 'warp.types.float64'>], b: quaternion[<class 'warp.types.float64'>], t: float64) → quaternion[<class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: quat, b: quat, t: float32) → quat¶
+warp.lerp(a: quaternion[<class 'warp.types.float32'>], b: quaternion[<class 'warp.types.float32'>], t: float32) → quaternion[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: transformh, b: transformh, t: float16) → transformh¶
+warp.lerp(a: transform_t[<class 'warp.types.float16'>], b: transform_t[<class 'warp.types.float16'>], t: float16) → transform_t[<class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: transformf, b: transformf, t: float32) → transformf¶
+warp.lerp(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>], t: float32) → transform_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: transformd, b: transformd, t: float64) → transformd¶
+warp.lerp(a: transform_t[<class 'warp.types.float64'>], b: transform_t[<class 'warp.types.float64'>], t: float64) → transform_t[<class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: transform, b: transform, t: float32) → transform¶
+warp.lerp(a: transform_t[<class 'warp.types.float32'>], b: transform_t[<class 'warp.types.float32'>], t: float32) → transform_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_vectorh, b: spatial_vectorh, t: float16) → spatial_vectorh¶
+warp.lerp(a: spatial_vector_t[<class 'warp.types.float16'>], b: spatial_vector_t[<class 'warp.types.float16'>], t: float16) → spatial_vector_t[<class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_vectorf, b: spatial_vectorf, t: float32) → spatial_vectorf¶
+warp.lerp(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>], t: float32) → spatial_vector_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_vectord, b: spatial_vectord, t: float64) → spatial_vectord¶
+warp.lerp(a: spatial_vector_t[<class 'warp.types.float64'>], b: spatial_vector_t[<class 'warp.types.float64'>], t: float64) → spatial_vector_t[<class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_vector, b: spatial_vector, t: float32) → spatial_vector¶
+warp.lerp(a: spatial_vector_t[<class 'warp.types.float32'>], b: spatial_vector_t[<class 'warp.types.float32'>], t: float32) → spatial_vector_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_matrixh, b: spatial_matrixh, t: float16) → spatial_matrixh¶
+warp.lerp(a: spatial_matrix_t[<class 'warp.types.float16'>], b: spatial_matrix_t[<class 'warp.types.float16'>], t: float16) → spatial_matrix_t[<class 'warp.types.float16'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_matrixf, b: spatial_matrixf, t: float32) → spatial_matrixf¶
+warp.lerp(a: spatial_matrix_t[<class 'warp.types.float32'>], b: spatial_matrix_t[<class 'warp.types.float32'>], t: float32) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_matrixd, b: spatial_matrixd, t: float64) → spatial_matrixd¶
+warp.lerp(a: spatial_matrix_t[<class 'warp.types.float64'>], b: spatial_matrix_t[<class 'warp.types.float64'>], t: float64) → spatial_matrix_t[<class 'warp.types.float64'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.lerp(a: spatial_matrix, b: spatial_matrix, t: float32) → spatial_matrix¶
+warp.lerp(a: spatial_matrix_t[<class 'warp.types.float32'>], b: spatial_matrix_t[<class 'warp.types.float32'>], t: float32) → spatial_matrix_t[<class 'warp.types.float32'>]¶

Linearly interpolate two values a and b using factor t, computed as a*(1-t) + b*t

-warp.smoothstep(edge0: float16, edge1: float16, x: float16) → float16¶
+warp.smoothstep(edge0: float64, edge1: float64, x: float64) → float64¶

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.smoothstep(edge0: float64, edge1: float64, x: float64) → float64¶
+warp.smoothstep(edge0: float32, edge1: float32, x: float32) → float32¶

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.smoothstep(edge0: float32, edge1: float32, x: float32) → float32¶
+warp.smoothstep(edge0: float16, edge1: float16, x: float16) → float16¶

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

@@ -5845,19 +5845,19 @@

Utility
-warp.expect_near(arg1: float16, arg2: float16, tolerance: float16) → None¶
+warp.expect_near(arg1: float64, arg2: float64, tolerance: float64) → None¶

Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude

-warp.expect_near(arg1: float64, arg2: float64, tolerance: float64) → None¶
+warp.expect_near(arg1: float32, arg2: float32, tolerance: float32) → None¶

Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude

-warp.expect_near(arg1: float32, arg2: float32, tolerance: float32) → None¶
+warp.expect_near(arg1: float16, arg2: float16, tolerance: float16) → None¶

Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude

@@ -5869,7 +5869,7 @@

Utility
-warp.expect_near(arg1: vec3, arg2: vec3, tolerance: float32) → None¶
+warp.expect_near(arg1: vec[3, <class 'warp.types.float32'>], arg2: vec[3, <class 'warp.types.float32'>], tolerance: float32) → None¶

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

@@ -5878,7 +5878,7 @@

Utility¶

-warp.bvh_query_aabb(id: uint64, lower: vec3, upper: vec3) → bvh_query_t¶
+warp.bvh_query_aabb(id: uint64, lower: vec[3, <class 'warp.types.float32'>], upper: vec[3, <class 'warp.types.float32'>]) → 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. Returns an object that is used to track state during bvh traversal.

@@ -5894,7 +5894,7 @@

Geometry
-warp.bvh_query_ray(id: uint64, start: vec3, dir: vec3) → bvh_query_t¶
+warp.bvh_query_ray(id: uint64, start: vec[3, <class 'warp.types.float32'>], dir: vec[3, <class 'warp.types.float32'>]) → 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. Returns an object that is used to track state during bvh traversal.

@@ -5917,7 +5917,7 @@

Geometry
-warp.mesh_query_point(id: uint64, point: vec3, max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) → bool¶
+warp.mesh_query_point(id: uint64, point: vec[3, <class 'warp.types.float32'>], max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) → bool¶

Computes the closest point on the mesh with identifier id to the given point in space. Returns True if a point < max_dist is found.

Parameters
@@ -5936,7 +5936,7 @@

Geometry
-warp.mesh_query_ray(id: uint64, start: vec3, dir: vec3, max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec3, face: int32) → bool¶
+warp.mesh_query_ray(id: uint64, start: vec[3, <class 'warp.types.float32'>], dir: vec[3, <class 'warp.types.float32'>], max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec[3, <class 'warp.types.float32'>], face: int32) → bool¶

Computes the closest ray hit on the mesh with identifier id, returns True if a point < max_t is found.

Parameters
@@ -5958,7 +5958,7 @@

Geometry
-warp.mesh_query_aabb(id: uint64, lower: vec3, upper: vec3) → mesh_query_aabb_t¶
+warp.mesh_query_aabb(id: uint64, lower: vec[3, <class 'warp.types.float32'>], upper: vec[3, <class 'warp.types.float32'>]) → mesh_query_aabb_t¶

Construct an axis-aligned bounding box query against a mesh object. This query can be used to iterate over all triangles inside a volume. Returns an object that is used to track state during mesh traversal.

@@ -5981,19 +5981,19 @@

Geometry
-warp.mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) → vec3¶
+warp.mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) → vec[3, <class 'warp.types.float32'>]¶

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) → vec3¶
+warp.mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.hash_grid_query(id: uint64, point: vec3, max_dist: float32) → hash_grid_query_t¶
+warp.hash_grid_query(id: uint64, point: vec[3, <class 'warp.types.float32'>], max_dist: float32) → hash_grid_query_t¶

Construct a point query against a hash grid. This query can be used to iterate over all neighboring points withing a fixed radius from the query point. Returns an object that is used to track state during neighbor traversal.

@@ -6014,7 +6014,7 @@

Geometry
-warp.intersect_tri_tri(v0: vec3, v1: vec3, v2: vec3, u0: vec3, u1: vec3, u2: vec3) → int¶
+warp.intersect_tri_tri(v0: vec[3, <class 'warp.types.float32'>], v1: vec[3, <class 'warp.types.float32'>], v2: vec[3, <class 'warp.types.float32'>], u0: vec[3, <class 'warp.types.float32'>], u1: vec[3, <class 'warp.types.float32'>], u2: vec[3, <class 'warp.types.float32'>]) → int¶

Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller’s method. Returns > 0 if triangles intersect.

@@ -6026,19 +6026,19 @@

Geometry
-warp.mesh_eval_face_normal(id: uint64, face: int32) → vec3¶
+warp.mesh_eval_face_normal(id: uint64, face: int32) → vec[3, <class 'warp.types.float32'>]¶

Evaluates the face normal the mesh given a face index.

-warp.mesh_get_point(id: uint64, index: int32) → vec3¶
+warp.mesh_get_point(id: uint64, index: int32) → vec[3, <class 'warp.types.float32'>]¶

Returns the point of the mesh given a index.

-warp.mesh_get_velocity(id: uint64, index: int32) → vec3¶
+warp.mesh_get_velocity(id: uint64, index: int32) → vec[3, <class 'warp.types.float32'>]¶

Returns the velocity of the mesh given a index.

@@ -6050,7 +6050,7 @@

Geometry
-warp.closest_point_edge_edge(p1: vec3, q1: vec3, p2: vec3, q2: vec3, epsilon: float32) → vec3¶
+warp.closest_point_edge_edge(p1: vec[3, <class 'warp.types.float32'>], q1: vec[3, <class 'warp.types.float32'>], p2: vec[3, <class 'warp.types.float32'>], q2: vec[3, <class 'warp.types.float32'>], epsilon: float32) → vec[3, <class 'warp.types.float32'>]¶

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
@@ -6071,7 +6071,7 @@

Geometry¶

-warp.volume_sample_f(id: uint64, uvw: vec3, sampling_mode: int32) → float¶
+warp.volume_sample_f(id: uint64, uvw: vec[3, <class 'warp.types.float32'>], sampling_mode: int32) → float¶

Sample the volume given by id at the volume local-space point uvw. Interpolation should be wp.Volume.CLOSEST, or wp.Volume.LINEAR.

@@ -6089,25 +6089,25 @@

Volumes
-warp.volume_sample_v(id: uint64, uvw: vec3, sampling_mode: int32) → vec3¶
+warp.volume_sample_v(id: uint64, uvw: vec[3, <class 'warp.types.float32'>], sampling_mode: int32) → vec[3, <class 'warp.types.float32'>]¶

Sample the vector volume given by id at the volume local-space point uvw. Interpolation should be wp.Volume.CLOSEST, or wp.Volume.LINEAR.

-warp.volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) → vec3¶
+warp.volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) → vec[3, <class 'warp.types.float32'>]¶

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: vec3) → None¶
+warp.volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec[3, <class 'warp.types.float32'>]) → None¶

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

-warp.volume_sample_i(id: uint64, uvw: vec3) → int¶
+warp.volume_sample_i(id: uint64, uvw: vec[3, <class 'warp.types.float32'>]) → int¶

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

@@ -6125,25 +6125,25 @@

Volumes
-warp.volume_index_to_world(id: uint64, uvw: vec3) → vec3¶
+warp.volume_index_to_world(id: uint64, uvw: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Transform a point defined in volume index space to world space given the volume’s intrinsic affine transformation.

-warp.volume_world_to_index(id: uint64, xyz: vec3) → vec3¶
+warp.volume_world_to_index(id: uint64, xyz: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Transform a point 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: vec3) → vec3¶
+warp.volume_index_to_world_dir(id: uint64, uvw: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Transform a direction defined in volume index space to world space given the volume’s intrinsic affine transformation.

-warp.volume_world_to_index_dir(id: uint64, xyz: vec3) → vec3¶
+warp.volume_world_to_index_dir(id: uint64, xyz: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

Transform a direction defined in volume world space to the volume’s index space, given the volume’s intrinsic affine transformation.

@@ -6202,55 +6202,55 @@

Random
-warp.sample_triangle(state: uint32) → vec2¶
+warp.sample_triangle(state: uint32) → vec[2, <class 'warp.types.float32'>]¶

Uniformly sample a triangle. Returns sample barycentric coordinates

-warp.sample_unit_ring(state: uint32) → vec2¶
+warp.sample_unit_ring(state: uint32) → vec[2, <class 'warp.types.float32'>]¶

Uniformly sample a ring in the xy plane

-warp.sample_unit_disk(state: uint32) → vec2¶
+warp.sample_unit_disk(state: uint32) → vec[2, <class 'warp.types.float32'>]¶

Uniformly sample a disk in the xy plane

-warp.sample_unit_sphere_surface(state: uint32) → vec3¶
+warp.sample_unit_sphere_surface(state: uint32) → vec[3, <class 'warp.types.float32'>]¶

Uniformly sample a unit sphere surface

-warp.sample_unit_sphere(state: uint32) → vec3¶
+warp.sample_unit_sphere(state: uint32) → vec[3, <class 'warp.types.float32'>]¶

Uniformly sample a unit sphere

-warp.sample_unit_hemisphere_surface(state: uint32) → vec3¶
+warp.sample_unit_hemisphere_surface(state: uint32) → vec[3, <class 'warp.types.float32'>]¶

Uniformly sample a unit hemisphere surface

-warp.sample_unit_hemisphere(state: uint32) → vec3¶
+warp.sample_unit_hemisphere(state: uint32) → vec[3, <class 'warp.types.float32'>]¶

Uniformly sample a unit hemisphere

-warp.sample_unit_square(state: uint32) → vec2¶
+warp.sample_unit_square(state: uint32) → vec[2, <class 'warp.types.float32'>]¶

Uniformly sample a unit square

-warp.sample_unit_cube(state: uint32) → vec3¶
+warp.sample_unit_cube(state: uint32) → vec[3, <class 'warp.types.float32'>]¶

Uniformly sample a unit cube

@@ -6262,19 +6262,19 @@

Random
-warp.noise(state: uint32, xy: vec2) → float¶
+warp.noise(state: uint32, xy: vec[2, <class 'warp.types.float32'>]) → float¶

Non-periodic Perlin-style noise in 2d.

-warp.noise(state: uint32, xyz: vec3) → float¶
+warp.noise(state: uint32, xyz: vec[3, <class 'warp.types.float32'>]) → float¶

Non-periodic Perlin-style noise in 3d.

-warp.noise(state: uint32, xyzt: vec4) → float¶
+warp.noise(state: uint32, xyzt: vec[4, <class 'warp.types.float32'>]) → float¶

Non-periodic Perlin-style noise in 4d.

@@ -6286,37 +6286,37 @@

Random
-warp.pnoise(state: uint32, xy: vec2, px: int32, py: int32) → float¶
+warp.pnoise(state: uint32, xy: vec[2, <class 'warp.types.float32'>], px: int32, py: int32) → float¶

Periodic Perlin-style noise in 2d.

-warp.pnoise(state: uint32, xyz: vec3, px: int32, py: int32, pz: int32) → float¶
+warp.pnoise(state: uint32, xyz: vec[3, <class 'warp.types.float32'>], px: int32, py: int32, pz: int32) → float¶

Periodic Perlin-style noise in 3d.

-warp.pnoise(state: uint32, xyzt: vec4, px: int32, py: int32, pz: int32, pt: int32) → float¶
+warp.pnoise(state: uint32, xyzt: vec[4, <class 'warp.types.float32'>], px: int32, py: int32, pz: int32, pt: int32) → float¶

Periodic Perlin-style noise in 4d.

-warp.curlnoise(state: uint32, xy: vec2) → vec2¶
+warp.curlnoise(state: uint32, xy: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶

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

-warp.curlnoise(state: uint32, xyz: vec3) → vec3¶
+warp.curlnoise(state: uint32, xyz: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

-warp.curlnoise(state: uint32, xyzt: vec4) → vec3¶
+warp.curlnoise(state: uint32, xyzt: vec[4, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶

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

@@ -6325,13 +6325,13 @@

Random¶

-warp.lower_bound(arr: array[Scalar], value: int32) → int¶
+warp.lower_bound(arr: array[Scalar], value: uint32) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: int8) → int¶
+warp.lower_bound(arr: array[Scalar], value: int16) → int¶

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

@@ -6343,49 +6343,49 @@

Other
-warp.lower_bound(arr: array[Scalar], value: int16) → int¶
+warp.lower_bound(arr: array[Scalar], value: int8) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: uint32) → int¶
+warp.lower_bound(arr: array[Scalar], value: float16) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: float16) → int¶
+warp.lower_bound(arr: array[Scalar], value: uint16) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: uint64) → int¶
+warp.lower_bound(arr: array[Scalar], value: int32) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: uint16) → int¶
+warp.lower_bound(arr: array[Scalar], value: uint64) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: int64) → int¶
+warp.lower_bound(arr: array[Scalar], value: float32) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: uint8) → int¶
+warp.lower_bound(arr: array[Scalar], value: int64) → int¶

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

-warp.lower_bound(arr: array[Scalar], value: float32) → int¶
+warp.lower_bound(arr: array[Scalar], value: uint8) → int¶

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

@@ -6400,12 +6400,12 @@

Other

Operators¶

-warp.add(x: int32, y: int32) → int32¶
+warp.add(x: uint32, y: uint32) → uint32¶
-warp.add(x: int8, y: int8) → int8¶
+warp.add(x: int16, y: int16) → int16¶
@@ -6415,42 +6415,42 @@

Operators
-warp.add(x: int16, y: int16) → int16¶
+warp.add(x: int8, y: int8) → int8¶

-warp.add(x: uint32, y: uint32) → uint32¶
+warp.add(x: float16, y: float16) → float16¶
-warp.add(x: float16, y: float16) → float16¶
+warp.add(x: uint16, y: uint16) → uint16¶
-warp.add(x: uint64, y: uint64) → uint64¶
+warp.add(x: int32, y: int32) → int32¶
-warp.add(x: uint16, y: uint16) → uint16¶
+warp.add(x: uint64, y: uint64) → uint64¶
-warp.add(x: int64, y: int64) → int64¶
+warp.add(x: float32, y: float32) → float32¶
-warp.add(x: uint8, y: uint8) → uint8¶
+warp.add(x: int64, y: int64) → int64¶
-warp.add(x: float32, y: float32) → float32¶
+warp.add(x: uint8, y: uint8) → uint8¶
@@ -6460,357 +6460,357 @@

Operators
-warp.add(x: vec2h, y: vec2h) → vec2h¶
+warp.add(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

-warp.add(x: vec3h, y: vec3h) → vec3h¶
+warp.add(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶
-warp.add(x: vec4h, y: vec4h) → vec4h¶
+warp.add(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶
-warp.add(x: vec2d, y: vec2d) → vec2d¶
+warp.add(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.add(x: vec3d, y: vec3d) → vec3d¶
+warp.add(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.add(x: vec4d, y: vec4d) → vec4d¶
+warp.add(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.add(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.add(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.add(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.add(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.add(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.add(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.add(x: vec2f, y: vec2f) → vec2f¶
+warp.add(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.add(x: vec2f, y: vec2) → vec2f¶
+warp.add(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.add(x: vec2, y: vec2f) → vec2f¶
+warp.add(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.add(x: vec2, y: vec2) → vec2f¶
+warp.add(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.add(x: vec3f, y: vec3f) → vec3f¶
+warp.add(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.add(x: vec3f, y: vec3) → vec3f¶
+warp.add(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.add(x: vec3, y: vec3f) → vec3f¶
+warp.add(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶
-warp.add(x: vec3, y: vec3) → vec3f¶
+warp.add(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶
-warp.add(x: vec4f, y: vec4f) → vec4f¶
+warp.add(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶
-warp.add(x: vec4f, y: vec4) → vec4f¶
+warp.add(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶
-warp.add(x: vec4, y: vec4f) → vec4f¶
+warp.add(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶
-warp.add(x: vec4, y: vec4) → vec4f¶
+warp.add(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶
-warp.add(x: vector_t, y: vector_t) → vector_t¶
+warp.add(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶
-warp.add(x: quath, y: quath) → quath¶
+warp.add(x: quaternion[<class 'warp.types.float64'>], y: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶
-warp.add(x: quatd, y: quatd) → quatd¶
+warp.add(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.add(x: quatf, y: quatf) → quatf¶
+warp.add(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.add(x: quatf, y: quat) → quatf¶
+warp.add(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.add(x: quat, y: quatf) → quatf¶
+warp.add(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.add(x: quat, y: quat) → quatf¶
+warp.add(x: quaternion[<class 'warp.types.float16'>], y: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶
-warp.add(x: vector_t, y: vector_t) → vector_t¶
+warp.add(x: quaternion[Scalar], y: quaternion[Scalar]) → quaternion[Scalar]¶
-warp.add(x: mat22h, y: mat22h) → mat22h¶
+warp.add(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.add(x: mat33h, y: mat33h) → mat33h¶
+warp.add(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.add(x: mat44h, y: mat44h) → mat44h¶
+warp.add(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.add(x: mat22d, y: mat22d) → mat22d¶
+warp.add(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.add(x: mat33d, y: mat33d) → mat33d¶
+warp.add(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.add(x: mat44d, y: mat44d) → mat44d¶
+warp.add(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.add(x: mat22f, y: mat22f) → mat22f¶
+warp.add(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.add(x: mat22f, y: mat22) → mat22f¶
+warp.add(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.add(x: mat22, y: mat22f) → mat22f¶
+warp.add(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.add(x: mat22, y: mat22) → mat22f¶
+warp.add(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.add(x: mat33f, y: mat33f) → mat33f¶
+warp.add(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.add(x: mat33f, y: mat33) → mat33f¶
+warp.add(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.add(x: mat33, y: mat33f) → mat33f¶
+warp.add(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.add(x: mat33, y: mat33) → mat33f¶
+warp.add(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.add(x: mat44f, y: mat44f) → mat44f¶
+warp.add(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.add(x: mat44f, y: mat44) → mat44f¶
+warp.add(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.add(x: mat44, y: mat44f) → mat44f¶
+warp.add(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.add(x: mat44, y: mat44) → mat44f¶
+warp.add(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.add(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.add(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶
-warp.add(x: spatial_vectorh, y: spatial_vectorh) → spatial_vectorh¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float64'>], y: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶
-warp.add(x: spatial_vectord, y: spatial_vectord) → spatial_vectord¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_vectorf, y: spatial_vectorf) → spatial_vectorf¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_vectorf, y: spatial_vector) → spatial_vectorf¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_vector, y: spatial_vectorf) → spatial_vectorf¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_vector, y: spatial_vector) → spatial_vectorf¶
+warp.add(x: spatial_vector_t[<class 'warp.types.float16'>], y: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶
-warp.add(x: vector_t, y: vector_t) → vector_t¶
+warp.add(x: spatial_vector_t[Scalar], y: spatial_vector_t[Scalar]) → spatial_vector_t[Scalar]¶
-warp.add(x: spatial_matrixh, y: spatial_matrixh) → spatial_matrixh¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float64'>], y: spatial_matrix_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶
-warp.add(x: spatial_matrixd, y: spatial_matrixd) → spatial_matrixd¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_matrixf, y: spatial_matrixf) → spatial_matrixf¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_matrixf, y: spatial_matrix) → spatial_matrixf¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_matrix, y: spatial_matrixf) → spatial_matrixf¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.add(x: spatial_matrix, y: spatial_matrix) → spatial_matrixf¶
+warp.add(x: spatial_matrix_t[<class 'warp.types.float16'>], y: spatial_matrix_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶
-warp.add(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.add(x: spatial_matrix_t[Scalar], y: spatial_matrix_t[Scalar]) → spatial_matrix_t[Scalar]¶
-warp.add(x: transformh, y: transformh) → transformh¶
+warp.add(x: transform_t[<class 'warp.types.float64'>], y: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶
-warp.add(x: transformd, y: transformd) → transformd¶
+warp.add(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.add(x: transformf, y: transformf) → transformf¶
+warp.add(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.add(x: transformf, y: transform) → transformf¶
+warp.add(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.add(x: transform, y: transformf) → transformf¶
+warp.add(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.add(x: transform, y: transform) → transformf¶
+warp.add(x: transform_t[<class 'warp.types.float16'>], y: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶
-warp.add(x: transform_class, y: transform_class) → transform_class¶
+warp.add(x: transform_t[Scalar], y: transform_t[Scalar]) → transform_t[Scalar]¶
-warp.sub(x: int32, y: int32) → int32¶
+warp.sub(x: uint32, y: uint32) → uint32¶
-warp.sub(x: int8, y: int8) → int8¶
+warp.sub(x: int16, y: int16) → int16¶
@@ -6820,42 +6820,42 @@

Operators
-warp.sub(x: int16, y: int16) → int16¶
+warp.sub(x: int8, y: int8) → int8¶

-warp.sub(x: uint32, y: uint32) → uint32¶
+warp.sub(x: float16, y: float16) → float16¶
-warp.sub(x: float16, y: float16) → float16¶
+warp.sub(x: uint16, y: uint16) → uint16¶
-warp.sub(x: uint64, y: uint64) → uint64¶
+warp.sub(x: int32, y: int32) → int32¶
-warp.sub(x: uint16, y: uint16) → uint16¶
+warp.sub(x: uint64, y: uint64) → uint64¶
-warp.sub(x: int64, y: int64) → int64¶
+warp.sub(x: float32, y: float32) → float32¶
-warp.sub(x: uint8, y: uint8) → uint8¶
+warp.sub(x: int64, y: int64) → int64¶
-warp.sub(x: float32, y: float32) → float32¶
+warp.sub(x: uint8, y: uint8) → uint8¶
@@ -6865,357 +6865,357 @@

Operators
-warp.sub(x: vec2h, y: vec2h) → vec2h¶
+warp.sub(x: vec[2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

-warp.sub(x: vec3h, y: vec3h) → vec3h¶
+warp.sub(x: vec[3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶
-warp.sub(x: vec4h, y: vec4h) → vec4h¶
+warp.sub(x: vec[4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶
-warp.sub(x: vec2d, y: vec2d) → vec2d¶
+warp.sub(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.sub(x: vec3d, y: vec3d) → vec3d¶
+warp.sub(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.sub(x: vec4d, y: vec4d) → vec4d¶
+warp.sub(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.sub(x: vec2ub, y: vec2ub) → vec2ub¶
+warp.sub(x: vec[2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.sub(x: vec3ub, y: vec3ub) → vec3ub¶
+warp.sub(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.sub(x: vec4ub, y: vec4ub) → vec4ub¶
+warp.sub(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.sub(x: vec2f, y: vec2f) → vec2f¶
+warp.sub(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.sub(x: vec2f, y: vec2) → vec2f¶
+warp.sub(x: vec[3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.sub(x: vec2, y: vec2f) → vec2f¶
+warp.sub(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.sub(x: vec2, y: vec2) → vec2f¶
+warp.sub(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.sub(x: vec3f, y: vec3f) → vec3f¶
+warp.sub(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.sub(x: vec3f, y: vec3) → vec3f¶
+warp.sub(x: vec[4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.sub(x: vec3, y: vec3f) → vec3f¶
+warp.sub(x: vec[2, <class 'warp.types.uint8'>], y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶
-warp.sub(x: vec3, y: vec3) → vec3f¶
+warp.sub(x: vec[3, <class 'warp.types.uint8'>], y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶
-warp.sub(x: vec4f, y: vec4f) → vec4f¶
+warp.sub(x: vec[4, <class 'warp.types.uint8'>], y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶
-warp.sub(x: vec4f, y: vec4) → vec4f¶
+warp.sub(x: vec[2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶
-warp.sub(x: vec4, y: vec4f) → vec4f¶
+warp.sub(x: vec[3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶
-warp.sub(x: vec4, y: vec4) → vec4f¶
+warp.sub(x: vec[4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶
-warp.sub(x: vector_t, y: vector_t) → vector_t¶
+warp.sub(x: vec[Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶
-warp.sub(x: mat22h, y: mat22h) → mat22h¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.sub(x: mat33h, y: mat33h) → mat33h¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.sub(x: mat44h, y: mat44h) → mat44h¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.sub(x: mat22d, y: mat22d) → mat22d¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.sub(x: mat33d, y: mat33d) → mat33d¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.sub(x: mat44d, y: mat44d) → mat44d¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.sub(x: mat22f, y: mat22f) → mat22f¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.sub(x: mat22f, y: mat22) → mat22f¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.sub(x: mat22, y: mat22f) → mat22f¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.sub(x: mat22, y: mat22) → mat22f¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.sub(x: mat33f, y: mat33f) → mat33f¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.sub(x: mat33f, y: mat33) → mat33f¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.sub(x: mat33, y: mat33f) → mat33f¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.sub(x: mat33, y: mat33) → mat33f¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.sub(x: mat44f, y: mat44f) → mat44f¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.sub(x: mat44f, y: mat44) → mat44f¶
+warp.sub(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.sub(x: mat44, y: mat44f) → mat44f¶
+warp.sub(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.sub(x: mat44, y: mat44) → mat44f¶
+warp.sub(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.sub(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.sub(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶
-warp.sub(x: spatial_vectorh, y: spatial_vectorh) → spatial_vectorh¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float64'>], y: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶
-warp.sub(x: spatial_vectord, y: spatial_vectord) → spatial_vectord¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_vectorf, y: spatial_vectorf) → spatial_vectorf¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_vectorf, y: spatial_vector) → spatial_vectorf¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_vector, y: spatial_vectorf) → spatial_vectorf¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_vector, y: spatial_vector) → spatial_vectorf¶
+warp.sub(x: spatial_vector_t[<class 'warp.types.float16'>], y: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶
-warp.sub(x: vector_t, y: vector_t) → vector_t¶
+warp.sub(x: spatial_vector_t[Scalar], y: spatial_vector_t[Scalar]) → spatial_vector_t[Scalar]¶
-warp.sub(x: spatial_matrixh, y: spatial_matrixh) → spatial_matrixh¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float64'>], y: spatial_matrix_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶
-warp.sub(x: spatial_matrixd, y: spatial_matrixd) → spatial_matrixd¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_matrixf, y: spatial_matrixf) → spatial_matrixf¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_matrixf, y: spatial_matrix) → spatial_matrixf¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_matrix, y: spatial_matrixf) → spatial_matrixf¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.sub(x: spatial_matrix, y: spatial_matrix) → spatial_matrixf¶
+warp.sub(x: spatial_matrix_t[<class 'warp.types.float16'>], y: spatial_matrix_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶
-warp.sub(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.sub(x: spatial_matrix_t[Scalar], y: spatial_matrix_t[Scalar]) → spatial_matrix_t[Scalar]¶
-warp.sub(x: quath, y: quath) → quath¶
+warp.sub(x: quaternion[<class 'warp.types.float64'>], y: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶
-warp.sub(x: quatd, y: quatd) → quatd¶
+warp.sub(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.sub(x: quatf, y: quatf) → quatf¶
+warp.sub(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.sub(x: quatf, y: quat) → quatf¶
+warp.sub(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.sub(x: quat, y: quatf) → quatf¶
+warp.sub(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.sub(x: quat, y: quat) → quatf¶
+warp.sub(x: quaternion[<class 'warp.types.float16'>], y: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶
-warp.sub(x: vector_t, y: vector_t) → vector_t¶
+warp.sub(x: quaternion[Scalar], y: quaternion[Scalar]) → quaternion[Scalar]¶
-warp.sub(x: transformh, y: transformh) → transformh¶
+warp.sub(x: transform_t[<class 'warp.types.float64'>], y: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶
-warp.sub(x: transformd, y: transformd) → transformd¶
+warp.sub(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.sub(x: transformf, y: transformf) → transformf¶
+warp.sub(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.sub(x: transformf, y: transform) → transformf¶
+warp.sub(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.sub(x: transform, y: transformf) → transformf¶
+warp.sub(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.sub(x: transform, y: transform) → transformf¶
+warp.sub(x: transform_t[<class 'warp.types.float16'>], y: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶
-warp.sub(x: transform_class, y: transform_class) → transform_class¶
+warp.sub(x: transform_t[Scalar], y: transform_t[Scalar]) → transform_t[Scalar]¶
-warp.mul(x: int32, y: int32) → int32¶
+warp.mul(x: uint32, y: uint32) → uint32¶
-warp.mul(x: int8, y: int8) → int8¶
+warp.mul(x: int16, y: int16) → int16¶
@@ -7225,42 +7225,42 @@

Operators
-warp.mul(x: int16, y: int16) → int16¶
+warp.mul(x: int8, y: int8) → int8¶

-warp.mul(x: uint32, y: uint32) → uint32¶
+warp.mul(x: float16, y: float16) → float16¶
-warp.mul(x: float16, y: float16) → float16¶
+warp.mul(x: uint16, y: uint16) → uint16¶
-warp.mul(x: uint64, y: uint64) → uint64¶
+warp.mul(x: int32, y: int32) → int32¶
-warp.mul(x: uint16, y: uint16) → uint16¶
+warp.mul(x: uint64, y: uint64) → uint64¶
-warp.mul(x: int64, y: int64) → int64¶
+warp.mul(x: float32, y: float32) → float32¶
-warp.mul(x: uint8, y: uint8) → uint8¶
+warp.mul(x: int64, y: int64) → int64¶
-warp.mul(x: float32, y: float32) → float32¶
+warp.mul(x: uint8, y: uint8) → uint8¶
@@ -7270,832 +7270,832 @@

Operators
-warp.mul(x: vec2h, y: float16) → vec2h¶
+warp.mul(x: vec[2, <class 'warp.types.float64'>], y: float64) → vec[2, <class 'warp.types.float64'>]¶

-warp.mul(x: vec3h, y: float16) → vec3h¶
+warp.mul(x: vec[3, <class 'warp.types.float64'>], y: float64) → vec[3, <class 'warp.types.float64'>]¶
-warp.mul(x: vec4h, y: float16) → vec4h¶
+warp.mul(x: vec[4, <class 'warp.types.float64'>], y: float64) → vec[4, <class 'warp.types.float64'>]¶
-warp.mul(x: vec2d, y: float64) → vec2d¶
+warp.mul(x: vec[2, <class 'warp.types.float16'>], y: float16) → vec[2, <class 'warp.types.float16'>]¶
-warp.mul(x: vec3d, y: float64) → vec3d¶
+warp.mul(x: vec[3, <class 'warp.types.float16'>], y: float16) → vec[3, <class 'warp.types.float16'>]¶
-warp.mul(x: vec4d, y: float64) → vec4d¶
+warp.mul(x: vec[4, <class 'warp.types.float16'>], y: float16) → vec[4, <class 'warp.types.float16'>]¶
-warp.mul(x: vec2ub, y: uint8) → vec2ub¶
+warp.mul(x: vec[2, <class 'warp.types.uint8'>], y: uint8) → vec[2, <class 'warp.types.uint8'>]¶
-warp.mul(x: vec3ub, y: uint8) → vec3ub¶
+warp.mul(x: vec[3, <class 'warp.types.uint8'>], y: uint8) → vec[3, <class 'warp.types.uint8'>]¶
-warp.mul(x: vec4ub, y: uint8) → vec4ub¶
+warp.mul(x: vec[4, <class 'warp.types.uint8'>], y: uint8) → vec[4, <class 'warp.types.uint8'>]¶
-warp.mul(x: vec2f, y: float32) → vec2f¶
+warp.mul(x: vec[2, <class 'warp.types.float32'>], y: float32) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: vec2, y: float32) → vec2f¶
+warp.mul(x: vec[2, <class 'warp.types.float32'>], y: float32) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: vec3f, y: float32) → vec3f¶
+warp.mul(x: vec[3, <class 'warp.types.float32'>], y: float32) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: vec3, y: float32) → vec3f¶
+warp.mul(x: vec[3, <class 'warp.types.float32'>], y: float32) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: vec4f, y: float32) → vec4f¶
+warp.mul(x: vec[4, <class 'warp.types.float32'>], y: float32) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: vec4, y: float32) → vec4f¶
+warp.mul(x: vec[4, <class 'warp.types.float32'>], y: float32) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: vector_t, y: Scalar) → vector_t¶
+warp.mul(x: vec[Any, Scalar], y: Scalar) → vec[Any, Scalar]¶
-warp.mul(x: float16, y: vec2h) → vec2h¶
+warp.mul(x: float64, y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶
-warp.mul(x: float16, y: vec3h) → vec3h¶
+warp.mul(x: float64, y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶
-warp.mul(x: float16, y: vec4h) → vec4h¶
+warp.mul(x: float64, y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: vec2d) → vec2d¶
+warp.mul(x: float16, y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶
-warp.mul(x: float64, y: vec3d) → vec3d¶
+warp.mul(x: float16, y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶
-warp.mul(x: float64, y: vec4d) → vec4d¶
+warp.mul(x: float16, y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶
-warp.mul(x: uint8, y: vec2ub) → vec2ub¶
+warp.mul(x: uint8, y: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶
-warp.mul(x: uint8, y: vec3ub) → vec3ub¶
+warp.mul(x: uint8, y: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶
-warp.mul(x: uint8, y: vec4ub) → vec4ub¶
+warp.mul(x: uint8, y: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶
-warp.mul(x: float32, y: vec2f) → vec2f¶
+warp.mul(x: float32, y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: vec2) → vec2f¶
+warp.mul(x: float32, y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: vec3f) → vec3f¶
+warp.mul(x: float32, y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: vec3) → vec3f¶
+warp.mul(x: float32, y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: vec4f) → vec4f¶
+warp.mul(x: float32, y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: vec4) → vec4f¶
+warp.mul(x: float32, y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: vector_t) → vector_t¶
+warp.mul(x: Scalar, y: vec[Any, Scalar]) → vec[Any, Scalar]¶
-warp.mul(x: quath, y: float16) → quath¶
+warp.mul(x: quaternion[<class 'warp.types.float64'>], y: float64) → quaternion[<class 'warp.types.float64'>]¶
-warp.mul(x: quatd, y: float64) → quatd¶
+warp.mul(x: quaternion[<class 'warp.types.float16'>], y: float16) → quaternion[<class 'warp.types.float16'>]¶
-warp.mul(x: quatf, y: float32) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: float32) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: quat, y: float32) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: float32) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: vector_t, y: Scalar) → vector_t¶
+warp.mul(x: quaternion[Scalar], y: Scalar) → quaternion[Scalar]¶
-warp.mul(x: float16, y: quath) → quath¶
+warp.mul(x: float64, y: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: quatd) → quatd¶
+warp.mul(x: float16, y: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶
-warp.mul(x: float32, y: quatf) → quatf¶
+warp.mul(x: float32, y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: quat) → quatf¶
+warp.mul(x: float32, y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: vector_t) → vector_t¶
+warp.mul(x: Scalar, y: quaternion[Scalar]) → quaternion[Scalar]¶
-warp.mul(x: quath, y: quath) → quath¶
+warp.mul(x: quaternion[<class 'warp.types.float64'>], y: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶
-warp.mul(x: quatd, y: quatd) → quatd¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: quatf, y: quatf) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: quatf, y: quat) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: quat, y: quatf) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float32'>], y: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.mul(x: quat, y: quat) → quatf¶
+warp.mul(x: quaternion[<class 'warp.types.float16'>], y: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶
-warp.mul(x: vector_t, y: vector_t) → vector_t¶
+warp.mul(x: quaternion[Scalar], y: quaternion[Scalar]) → quaternion[Scalar]¶
-warp.mul(x: float16, y: mat22h) → mat22h¶
+warp.mul(x: float64, y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.mul(x: float16, y: mat33h) → mat33h¶
+warp.mul(x: float64, y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.mul(x: float16, y: mat44h) → mat44h¶
+warp.mul(x: float64, y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: mat22d) → mat22d¶
+warp.mul(x: float16, y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.mul(x: float64, y: mat33d) → mat33d¶
+warp.mul(x: float16, y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.mul(x: float64, y: mat44d) → mat44d¶
+warp.mul(x: float16, y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.mul(x: float32, y: mat22f) → mat22f¶
+warp.mul(x: float32, y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: mat22) → mat22f¶
+warp.mul(x: float32, y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: mat33f) → mat33f¶
+warp.mul(x: float32, y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: mat33) → mat33f¶
+warp.mul(x: float32, y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: mat44f) → mat44f¶
+warp.mul(x: float32, y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: mat44) → mat44f¶
+warp.mul(x: float32, y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: matrix_t) → matrix_t¶
+warp.mul(x: Scalar, y: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶
-warp.mul(x: mat22h, y: float16) → mat22h¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float64'>], y: float64) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.mul(x: mat33h, y: float16) → mat33h¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float64'>], y: float64) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.mul(x: mat44h, y: float16) → mat44h¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float64'>], y: float64) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.mul(x: mat22d, y: float64) → mat22d¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float16'>], y: float16) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.mul(x: mat33d, y: float64) → mat33d¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float16'>], y: float16) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.mul(x: mat44d, y: float64) → mat44d¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float16'>], y: float16) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.mul(x: mat22f, y: float32) → mat22f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: float32) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22, y: float32) → mat22f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: float32) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33f, y: float32) → mat33f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: float32) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33, y: float32) → mat33f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: float32) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44f, y: float32) → mat44f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: float32) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44, y: float32) → mat44f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: float32) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: matrix_t, y: Scalar) → matrix_t¶
+warp.mul(x: mat[Any, Any, Scalar], y: Scalar) → mat[Any, Any, Scalar]¶
-warp.mul(x: mat22h, y: vec2h) → vec2h¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float64'>], y: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶
-warp.mul(x: mat33h, y: vec3h) → vec3h¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float64'>], y: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶
-warp.mul(x: mat44h, y: vec4h) → vec4h¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float64'>], y: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶
-warp.mul(x: mat22d, y: vec2d) → vec2d¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float16'>], y: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶
-warp.mul(x: mat33d, y: vec3d) → vec3d¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float16'>], y: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶
-warp.mul(x: mat44d, y: vec4d) → vec4d¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float16'>], y: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶
-warp.mul(x: mat22f, y: vec2f) → vec2f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22f, y: vec2) → vec2f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22, y: vec2f) → vec2f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22, y: vec2) → vec2f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33f, y: vec3f) → vec3f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33f, y: vec3) → vec3f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33, y: vec3f) → vec3f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33, y: vec3) → vec3f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44f, y: vec4f) → vec4f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44f, y: vec4) → vec4f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44, y: vec4f) → vec4f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44, y: vec4) → vec4f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.mul(x: matrix_t, y: vector_t) → vector_t¶
+warp.mul(x: mat[Any, Any, Scalar], y: vec[Any, Scalar]) → vec[Any, Scalar]¶
-warp.mul(x: mat22h, y: mat22h) → mat22h¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float64'>], y: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.mul(x: mat33h, y: mat33h) → mat33h¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float64'>], y: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.mul(x: mat44h, y: mat44h) → mat44h¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float64'>], y: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.mul(x: mat22d, y: mat22d) → mat22d¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33d, y: mat33d) → mat33d¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44d, y: mat44d) → mat44d¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22f, y: mat22f) → mat22f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float32'>], y: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22f, y: mat22) → mat22f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22, y: mat22f) → mat22f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat22, y: mat22) → mat22f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33f, y: mat33f) → mat33f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float32'>], y: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33f, y: mat33) → mat33f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33, y: mat33f) → mat33f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat33, y: mat33) → mat33f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44f, y: mat44f) → mat44f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float32'>], y: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.mul(x: mat44f, y: mat44) → mat44f¶
+warp.mul(x: mat[2, 2, <class 'warp.types.float16'>], y: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.mul(x: mat44, y: mat44f) → mat44f¶
+warp.mul(x: mat[3, 3, <class 'warp.types.float16'>], y: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.mul(x: mat44, y: mat44) → mat44f¶
+warp.mul(x: mat[4, 4, <class 'warp.types.float16'>], y: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.mul(x: matrix_t, y: matrix_t)¶
+warp.mul(x: mat[Any, Any, Scalar], y: mat[Any, Any, Scalar])¶
-warp.mul(x: spatial_vectorh, y: float16) → spatial_vectorh¶
+warp.mul(x: spatial_vector_t[<class 'warp.types.float64'>], y: float64) → spatial_vector_t[<class 'warp.types.float64'>]¶
-warp.mul(x: spatial_vectord, y: float64) → spatial_vectord¶
+warp.mul(x: spatial_vector_t[<class 'warp.types.float16'>], y: float16) → spatial_vector_t[<class 'warp.types.float16'>]¶
-warp.mul(x: spatial_vectorf, y: float32) → spatial_vectorf¶
+warp.mul(x: spatial_vector_t[<class 'warp.types.float32'>], y: float32) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_vector, y: float32) → spatial_vectorf¶
+warp.mul(x: spatial_vector_t[<class 'warp.types.float32'>], y: float32) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: vector_t, y: Scalar) → vector_t¶
+warp.mul(x: spatial_vector_t[Scalar], y: Scalar) → spatial_vector_t[Scalar]¶
-warp.mul(x: float16, y: spatial_vectorh) → spatial_vectorh¶
+warp.mul(x: float64, y: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: spatial_vectord) → spatial_vectord¶
+warp.mul(x: float16, y: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶
-warp.mul(x: float32, y: spatial_vectorf) → spatial_vectorf¶
+warp.mul(x: float32, y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: spatial_vector) → spatial_vectorf¶
+warp.mul(x: float32, y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: vector_t) → vector_t¶
+warp.mul(x: Scalar, y: spatial_vector_t[Scalar]) → spatial_vector_t[Scalar]¶
-warp.mul(x: spatial_matrixh, y: spatial_matrixh) → spatial_matrixh¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float64'>], y: spatial_matrix_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶
-warp.mul(x: spatial_matrixd, y: spatial_matrixd) → spatial_matrixd¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrixf, y: spatial_matrixf) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrixf, y: spatial_matrix) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrix, y: spatial_matrixf) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrix, y: spatial_matrix) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float16'>], y: spatial_matrix_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶
-warp.mul(x: matrix_t, y: matrix_t) → matrix_t¶
+warp.mul(x: spatial_matrix_t[Scalar], y: spatial_matrix_t[Scalar]) → spatial_matrix_t[Scalar]¶
-warp.mul(x: spatial_matrixh, y: spatial_vectorh) → spatial_vectorh¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float64'>], y: spatial_vector_t[<class 'warp.types.float64'>]) → spatial_vector_t[<class 'warp.types.float64'>]¶
-warp.mul(x: spatial_matrixd, y: spatial_vectord) → spatial_vectord¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float16'>], y: spatial_vector_t[<class 'warp.types.float16'>]) → spatial_vector_t[<class 'warp.types.float16'>]¶
-warp.mul(x: spatial_matrixf, y: spatial_vectorf) → spatial_vectorf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrixf, y: spatial_vector) → spatial_vectorf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrix, y: spatial_vectorf) → spatial_vectorf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrix, y: spatial_vector) → spatial_vectorf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: spatial_vector_t[<class 'warp.types.float32'>]) → spatial_vector_t[<class 'warp.types.float32'>]¶
-warp.mul(x: matrix_t, y: vector_t) → vector_t¶
+warp.mul(x: spatial_matrix_t[Scalar], y: spatial_vector_t[Scalar]) → spatial_vector_t[Scalar]¶
-warp.mul(x: spatial_matrixh, y: float16) → spatial_matrixh¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float64'>], y: float64) → spatial_matrix_t[<class 'warp.types.float64'>]¶
-warp.mul(x: spatial_matrixd, y: float64) → spatial_matrixd¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float16'>], y: float16) → spatial_matrix_t[<class 'warp.types.float16'>]¶
-warp.mul(x: spatial_matrixf, y: float32) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: float32) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: spatial_matrix, y: float32) → spatial_matrixf¶
+warp.mul(x: spatial_matrix_t[<class 'warp.types.float32'>], y: float32) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: matrix_t, y: Scalar) → matrix_t¶
+warp.mul(x: spatial_matrix_t[Scalar], y: Scalar) → spatial_matrix_t[Scalar]¶
-warp.mul(x: float16, y: spatial_matrixh) → spatial_matrixh¶
+warp.mul(x: float64, y: spatial_matrix_t[<class 'warp.types.float64'>]) → spatial_matrix_t[<class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: spatial_matrixd) → spatial_matrixd¶
+warp.mul(x: float16, y: spatial_matrix_t[<class 'warp.types.float16'>]) → spatial_matrix_t[<class 'warp.types.float16'>]¶
-warp.mul(x: float32, y: spatial_matrixf) → spatial_matrixf¶
+warp.mul(x: float32, y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: spatial_matrix) → spatial_matrixf¶
+warp.mul(x: float32, y: spatial_matrix_t[<class 'warp.types.float32'>]) → spatial_matrix_t[<class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: matrix_t) → matrix_t¶
+warp.mul(x: Scalar, y: spatial_matrix_t[Scalar]) → spatial_matrix_t[Scalar]¶
-warp.mul(x: transformh, y: transformh) → transformh¶
+warp.mul(x: transform_t[<class 'warp.types.float64'>], y: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶
-warp.mul(x: transformd, y: transformd) → transformd¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transformf, y: transformf) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transformf, y: transform) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transform, y: transformf) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transform, y: transform) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float16'>], y: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶
-warp.mul(x: transform_class, y: transform_class) → transform_class¶
+warp.mul(x: transform_t[Scalar], y: transform_t[Scalar]) → transform_t[Scalar]¶
-warp.mul(x: float16, y: transformh) → transformh¶
+warp.mul(x: float64, y: transform_t[<class 'warp.types.float64'>]) → transform_t[<class 'warp.types.float64'>]¶
-warp.mul(x: float64, y: transformd) → transformd¶
+warp.mul(x: float16, y: transform_t[<class 'warp.types.float16'>]) → transform_t[<class 'warp.types.float16'>]¶
-warp.mul(x: float32, y: transformf) → transformf¶
+warp.mul(x: float32, y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: float32, y: transform) → transformf¶
+warp.mul(x: float32, y: transform_t[<class 'warp.types.float32'>]) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: Scalar, y: transform_class) → transform_class¶
+warp.mul(x: Scalar, y: transform_t[Scalar]) → transform_t[Scalar]¶
-warp.mul(x: transformh, y: float16) → transformh¶
+warp.mul(x: transform_t[<class 'warp.types.float64'>], y: float64) → transform_t[<class 'warp.types.float64'>]¶
-warp.mul(x: transformd, y: float64) → transformd¶
+warp.mul(x: transform_t[<class 'warp.types.float16'>], y: float16) → transform_t[<class 'warp.types.float16'>]¶
-warp.mul(x: transformf, y: float32) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: float32) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transform, y: float32) → transformf¶
+warp.mul(x: transform_t[<class 'warp.types.float32'>], y: float32) → transform_t[<class 'warp.types.float32'>]¶
-warp.mul(x: transform_class, y: Scalar) → transform_class¶
+warp.mul(x: transform_t[Scalar], y: Scalar) → transform_t[Scalar]¶
-warp.mod(x: int32, y: int32) → int32¶
+warp.mod(x: uint32, y: uint32) → uint32¶
-warp.mod(x: int8, y: int8) → int8¶
+warp.mod(x: int16, y: int16) → int16¶
@@ -8105,42 +8105,42 @@

Operators
-warp.mod(x: int16, y: int16) → int16¶
+warp.mod(x: int8, y: int8) → int8¶

-warp.mod(x: uint32, y: uint32) → uint32¶
+warp.mod(x: float16, y: float16) → float16¶
-warp.mod(x: float16, y: float16) → float16¶
+warp.mod(x: uint16, y: uint16) → uint16¶
-warp.mod(x: uint64, y: uint64) → uint64¶
+warp.mod(x: int32, y: int32) → int32¶
-warp.mod(x: uint16, y: uint16) → uint16¶
+warp.mod(x: uint64, y: uint64) → uint64¶
-warp.mod(x: int64, y: int64) → int64¶
+warp.mod(x: float32, y: float32) → float32¶
-warp.mod(x: uint8, y: uint8) → uint8¶
+warp.mod(x: int64, y: int64) → int64¶
-warp.mod(x: float32, y: float32) → float32¶
+warp.mod(x: uint8, y: uint8) → uint8¶
@@ -8150,12 +8150,12 @@

Operators
-warp.div(x: int32, y: int32) → int32¶
+warp.div(x: uint32, y: uint32) → uint32¶

-warp.div(x: int8, y: int8) → int8¶
+warp.div(x: int16, y: int16) → int16¶
@@ -8165,42 +8165,42 @@

Operators
-warp.div(x: int16, y: int16) → int16¶
+warp.div(x: int8, y: int8) → int8¶

-warp.div(x: uint32, y: uint32) → uint32¶
+warp.div(x: float16, y: float16) → float16¶
-warp.div(x: float16, y: float16) → float16¶
+warp.div(x: uint16, y: uint16) → uint16¶
-warp.div(x: uint64, y: uint64) → uint64¶
+warp.div(x: int32, y: int32) → int32¶
-warp.div(x: uint16, y: uint16) → uint16¶
+warp.div(x: uint64, y: uint64) → uint64¶
-warp.div(x: int64, y: int64) → int64¶
+warp.div(x: float32, y: float32) → float32¶
-warp.div(x: uint8, y: uint8) → uint8¶
+warp.div(x: int64, y: int64) → int64¶
-warp.div(x: float32, y: float32) → float32¶
+warp.div(x: uint8, y: uint8) → uint8¶
@@ -8210,182 +8210,182 @@

Operators
-warp.div(x: vec2h, y: float16) → vec2h¶
+warp.div(x: vec[2, <class 'warp.types.float64'>], y: float64) → vec[2, <class 'warp.types.float64'>]¶

-warp.div(x: vec3h, y: float16) → vec3h¶
+warp.div(x: vec[3, <class 'warp.types.float64'>], y: float64) → vec[3, <class 'warp.types.float64'>]¶
-warp.div(x: vec4h, y: float16) → vec4h¶
+warp.div(x: vec[4, <class 'warp.types.float64'>], y: float64) → vec[4, <class 'warp.types.float64'>]¶
-warp.div(x: vec2d, y: float64) → vec2d¶
+warp.div(x: vec[2, <class 'warp.types.float16'>], y: float16) → vec[2, <class 'warp.types.float16'>]¶
-warp.div(x: vec3d, y: float64) → vec3d¶
+warp.div(x: vec[3, <class 'warp.types.float16'>], y: float16) → vec[3, <class 'warp.types.float16'>]¶
-warp.div(x: vec4d, y: float64) → vec4d¶
+warp.div(x: vec[4, <class 'warp.types.float16'>], y: float16) → vec[4, <class 'warp.types.float16'>]¶
-warp.div(x: vec2ub, y: uint8) → vec2ub¶
+warp.div(x: vec[2, <class 'warp.types.uint8'>], y: uint8) → vec[2, <class 'warp.types.uint8'>]¶
-warp.div(x: vec3ub, y: uint8) → vec3ub¶
+warp.div(x: vec[3, <class 'warp.types.uint8'>], y: uint8) → vec[3, <class 'warp.types.uint8'>]¶
-warp.div(x: vec4ub, y: uint8) → vec4ub¶
+warp.div(x: vec[4, <class 'warp.types.uint8'>], y: uint8) → vec[4, <class 'warp.types.uint8'>]¶
-warp.div(x: vec2f, y: float32) → vec2f¶
+warp.div(x: vec[2, <class 'warp.types.float32'>], y: float32) → vec[2, <class 'warp.types.float32'>]¶
-warp.div(x: vec2, y: float32) → vec2f¶
+warp.div(x: vec[2, <class 'warp.types.float32'>], y: float32) → vec[2, <class 'warp.types.float32'>]¶
-warp.div(x: vec3f, y: float32) → vec3f¶
+warp.div(x: vec[3, <class 'warp.types.float32'>], y: float32) → vec[3, <class 'warp.types.float32'>]¶
-warp.div(x: vec3, y: float32) → vec3f¶
+warp.div(x: vec[3, <class 'warp.types.float32'>], y: float32) → vec[3, <class 'warp.types.float32'>]¶
-warp.div(x: vec4f, y: float32) → vec4f¶
+warp.div(x: vec[4, <class 'warp.types.float32'>], y: float32) → vec[4, <class 'warp.types.float32'>]¶
-warp.div(x: vec4, y: float32) → vec4f¶
+warp.div(x: vec[4, <class 'warp.types.float32'>], y: float32) → vec[4, <class 'warp.types.float32'>]¶
-warp.div(x: vector_t, y: Scalar) → vector_t¶
+warp.div(x: vec[Any, Scalar], y: Scalar) → vec[Any, Scalar]¶
-warp.div(x: mat22h, y: float16) → mat22h¶
+warp.div(x: mat[2, 2, <class 'warp.types.float64'>], y: float64) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.div(x: mat33h, y: float16) → mat33h¶
+warp.div(x: mat[3, 3, <class 'warp.types.float64'>], y: float64) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.div(x: mat44h, y: float16) → mat44h¶
+warp.div(x: mat[4, 4, <class 'warp.types.float64'>], y: float64) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.div(x: mat22d, y: float64) → mat22d¶
+warp.div(x: mat[2, 2, <class 'warp.types.float16'>], y: float16) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.div(x: mat33d, y: float64) → mat33d¶
+warp.div(x: mat[3, 3, <class 'warp.types.float16'>], y: float16) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.div(x: mat44d, y: float64) → mat44d¶
+warp.div(x: mat[4, 4, <class 'warp.types.float16'>], y: float16) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.div(x: mat22f, y: float32) → mat22f¶
+warp.div(x: mat[2, 2, <class 'warp.types.float32'>], y: float32) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.div(x: mat22, y: float32) → mat22f¶
+warp.div(x: mat[2, 2, <class 'warp.types.float32'>], y: float32) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.div(x: mat33f, y: float32) → mat33f¶
+warp.div(x: mat[3, 3, <class 'warp.types.float32'>], y: float32) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.div(x: mat33, y: float32) → mat33f¶
+warp.div(x: mat[3, 3, <class 'warp.types.float32'>], y: float32) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.div(x: mat44f, y: float32) → mat44f¶
+warp.div(x: mat[4, 4, <class 'warp.types.float32'>], y: float32) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.div(x: mat44, y: float32) → mat44f¶
+warp.div(x: mat[4, 4, <class 'warp.types.float32'>], y: float32) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.div(x: matrix_t, y: Scalar) → matrix_t¶
+warp.div(x: mat[Any, Any, Scalar], y: Scalar) → mat[Any, Any, Scalar]¶
-warp.div(x: quath, y: float16) → quath¶
+warp.div(x: quaternion[<class 'warp.types.float64'>], y: float64) → quaternion[<class 'warp.types.float64'>]¶
-warp.div(x: quatd, y: float64) → quatd¶
+warp.div(x: quaternion[<class 'warp.types.float16'>], y: float16) → quaternion[<class 'warp.types.float16'>]¶
-warp.div(x: quatf, y: float32) → quatf¶
+warp.div(x: quaternion[<class 'warp.types.float32'>], y: float32) → quaternion[<class 'warp.types.float32'>]¶
-warp.div(x: quat, y: float32) → quatf¶
+warp.div(x: quaternion[<class 'warp.types.float32'>], y: float32) → quaternion[<class 'warp.types.float32'>]¶
-warp.div(x: vector_t, y: Scalar) → vector_t¶
+warp.div(x: quaternion[Scalar], y: Scalar) → quaternion[Scalar]¶
-warp.floordiv(x: int32, y: int32) → int32¶
+warp.floordiv(x: uint32, y: uint32) → uint32¶
-warp.floordiv(x: int8, y: int8) → int8¶
+warp.floordiv(x: int16, y: int16) → int16¶
@@ -8395,42 +8395,42 @@

Operators
-warp.floordiv(x: int16, y: int16) → int16¶
+warp.floordiv(x: int8, y: int8) → int8¶

-warp.floordiv(x: uint32, y: uint32) → uint32¶
+warp.floordiv(x: float16, y: float16) → float16¶
-warp.floordiv(x: float16, y: float16) → float16¶
+warp.floordiv(x: uint16, y: uint16) → uint16¶
-warp.floordiv(x: uint64, y: uint64) → uint64¶
+warp.floordiv(x: int32, y: int32) → int32¶
-warp.floordiv(x: uint16, y: uint16) → uint16¶
+warp.floordiv(x: uint64, y: uint64) → uint64¶
-warp.floordiv(x: int64, y: int64) → int64¶
+warp.floordiv(x: float32, y: float32) → float32¶
-warp.floordiv(x: uint8, y: uint8) → uint8¶
+warp.floordiv(x: int64, y: int64) → int64¶
-warp.floordiv(x: float32, y: float32) → float32¶
+warp.floordiv(x: uint8, y: uint8) → uint8¶
@@ -8440,12 +8440,12 @@

Operators
-warp.neg(x: int32) → int32¶
+warp.neg(x: uint32) → uint32¶

-warp.neg(x: int8) → int8¶
+warp.neg(x: int16) → int16¶
@@ -8455,42 +8455,42 @@

Operators
-warp.neg(x: int16) → int16¶
+warp.neg(x: int8) → int8¶

-warp.neg(x: uint32) → uint32¶
+warp.neg(x: float16) → float16¶
-warp.neg(x: float16) → float16¶
+warp.neg(x: uint16) → uint16¶
-warp.neg(x: uint64) → uint64¶
+warp.neg(x: int32) → int32¶
-warp.neg(x: uint16) → uint16¶
+warp.neg(x: uint64) → uint64¶
-warp.neg(x: int64) → int64¶
+warp.neg(x: float32) → float32¶
-warp.neg(x: uint8) → uint8¶
+warp.neg(x: int64) → int64¶
-warp.neg(x: float32) → float32¶
+warp.neg(x: uint8) → uint8¶
@@ -8500,172 +8500,172 @@

Operators
-warp.neg(x: vec2h) → vec2h¶
+warp.neg(x: vec[2, <class 'warp.types.float64'>]) → vec[2, <class 'warp.types.float64'>]¶

-warp.neg(x: vec3h) → vec3h¶
+warp.neg(x: vec[3, <class 'warp.types.float64'>]) → vec[3, <class 'warp.types.float64'>]¶
-warp.neg(x: vec4h) → vec4h¶
+warp.neg(x: vec[4, <class 'warp.types.float64'>]) → vec[4, <class 'warp.types.float64'>]¶
-warp.neg(x: vec2d) → vec2d¶
+warp.neg(x: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.neg(x: vec3d) → vec3d¶
+warp.neg(x: vec[2, <class 'warp.types.float32'>]) → vec[2, <class 'warp.types.float32'>]¶
-warp.neg(x: vec4d) → vec4d¶
+warp.neg(x: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.neg(x: vec2ub) → vec2ub¶
+warp.neg(x: vec[3, <class 'warp.types.float32'>]) → vec[3, <class 'warp.types.float32'>]¶
-warp.neg(x: vec3ub) → vec3ub¶
+warp.neg(x: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.neg(x: vec4ub) → vec4ub¶
+warp.neg(x: vec[4, <class 'warp.types.float32'>]) → vec[4, <class 'warp.types.float32'>]¶
-warp.neg(x: vec2f) → vec2f¶
+warp.neg(x: vec[2, <class 'warp.types.uint8'>]) → vec[2, <class 'warp.types.uint8'>]¶
-warp.neg(x: vec2) → vec2f¶
+warp.neg(x: vec[3, <class 'warp.types.uint8'>]) → vec[3, <class 'warp.types.uint8'>]¶
-warp.neg(x: vec3f) → vec3f¶
+warp.neg(x: vec[4, <class 'warp.types.uint8'>]) → vec[4, <class 'warp.types.uint8'>]¶
-warp.neg(x: vec3) → vec3f¶
+warp.neg(x: vec[2, <class 'warp.types.float16'>]) → vec[2, <class 'warp.types.float16'>]¶
-warp.neg(x: vec4f) → vec4f¶
+warp.neg(x: vec[3, <class 'warp.types.float16'>]) → vec[3, <class 'warp.types.float16'>]¶
-warp.neg(x: vec4) → vec4f¶
+warp.neg(x: vec[4, <class 'warp.types.float16'>]) → vec[4, <class 'warp.types.float16'>]¶
-warp.neg(x: vector_t) → vector_t¶
+warp.neg(x: vec[Any, Scalar]) → vec[Any, Scalar]¶
-warp.neg(x: quath) → quath¶
+warp.neg(x: quaternion[<class 'warp.types.float64'>]) → quaternion[<class 'warp.types.float64'>]¶
-warp.neg(x: quatd) → quatd¶
+warp.neg(x: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.neg(x: quatf) → quatf¶
+warp.neg(x: quaternion[<class 'warp.types.float32'>]) → quaternion[<class 'warp.types.float32'>]¶
-warp.neg(x: quat) → quatf¶
+warp.neg(x: quaternion[<class 'warp.types.float16'>]) → quaternion[<class 'warp.types.float16'>]¶
-warp.neg(x: vector_t) → vector_t¶
+warp.neg(x: quaternion[Scalar]) → quaternion[Scalar]¶
-warp.neg(x: mat22h) → mat22h¶
+warp.neg(x: mat[2, 2, <class 'warp.types.float64'>]) → mat[2, 2, <class 'warp.types.float64'>]¶
-warp.neg(x: mat33h) → mat33h¶
+warp.neg(x: mat[3, 3, <class 'warp.types.float64'>]) → mat[3, 3, <class 'warp.types.float64'>]¶
-warp.neg(x: mat44h) → mat44h¶
+warp.neg(x: mat[4, 4, <class 'warp.types.float64'>]) → mat[4, 4, <class 'warp.types.float64'>]¶
-warp.neg(x: mat22d) → mat22d¶
+warp.neg(x: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.neg(x: mat33d) → mat33d¶
+warp.neg(x: mat[2, 2, <class 'warp.types.float32'>]) → mat[2, 2, <class 'warp.types.float32'>]¶
-warp.neg(x: mat44d) → mat44d¶
+warp.neg(x: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.neg(x: mat22f) → mat22f¶
+warp.neg(x: mat[3, 3, <class 'warp.types.float32'>]) → mat[3, 3, <class 'warp.types.float32'>]¶
-warp.neg(x: mat22) → mat22f¶
+warp.neg(x: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.neg(x: mat33f) → mat33f¶
+warp.neg(x: mat[4, 4, <class 'warp.types.float32'>]) → mat[4, 4, <class 'warp.types.float32'>]¶
-warp.neg(x: mat33) → mat33f¶
+warp.neg(x: mat[2, 2, <class 'warp.types.float16'>]) → mat[2, 2, <class 'warp.types.float16'>]¶
-warp.neg(x: mat44f) → mat44f¶
+warp.neg(x: mat[3, 3, <class 'warp.types.float16'>]) → mat[3, 3, <class 'warp.types.float16'>]¶
-warp.neg(x: mat44) → mat44f¶
+warp.neg(x: mat[4, 4, <class 'warp.types.float16'>]) → mat[4, 4, <class 'warp.types.float16'>]¶
-warp.neg(x: matrix_t) → matrix_t¶
+warp.neg(x: mat[Any, Any, Scalar]) → mat[Any, Any, Scalar]¶
diff --git a/docs/_build/html/modules/introduction.html b/docs/_build/html/modules/introduction.html index 639364511..29562a7f3 100644 --- a/docs/_build/html/modules/introduction.html +++ b/docs/_build/html/modules/introduction.html @@ -71,7 +71,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/modules/runtime.html b/docs/_build/html/modules/runtime.html index 2c5707719..289ae95fb 100644 --- a/docs/_build/html/modules/runtime.html +++ b/docs/_build/html/modules/runtime.html @@ -72,7 +72,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/modules/sim.html b/docs/_build/html/modules/sim.html index e47a934e4..a75b866e2 100644 --- a/docs/_build/html/modules/sim.html +++ b/docs/_build/html/modules/sim.html @@ -71,7 +71,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/objects.inv b/docs/_build/html/objects.inv index f945d50b7d0bca2424b81efeec57f8ae45624f5e..c2ca0830b47f55453681dc422639dc0fa3225680 100644 GIT binary patch delta 12 Tcmew<`crg*4WrRU+dW(WBR2%l delta 12 Tcmew<`crg*4Wr>k+dW(WBQgZf diff --git a/docs/_build/html/search.html b/docs/_build/html/search.html index 7698434fd..d2c23ba4d 100644 --- a/docs/_build/html/search.html +++ b/docs/_build/html/search.html @@ -72,7 +72,7 @@
- 0.7.1 + 0.7.2
diff --git a/docs/_build/html/searchindex.js b/docs/_build/html/searchindex.js index 54b01ee33..fe6f2edf4 100644 --- a/docs/_build/html/searchindex.js +++ b/docs/_build/html/searchindex.js @@ -1 +1 @@ -Search.setIndex({docnames:["index","modules/functions","modules/introduction","modules/runtime","modules/sim"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":5,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.intersphinx":1,"sphinx.ext.todo":2,sphinx:56},filenames:["index.rst","modules\\functions.rst","modules\\introduction.rst","modules\\runtime.rst","modules\\sim.rst"],objects:{"warp.HashGrid":[[3,1,1,"","build"],[3,2,1,"","device"],[3,2,1,"","id"]],"warp.Mesh":[[3,2,1,"","device"],[3,2,1,"","id"],[3,1,1,"","refit"]],"warp.Volume":[[3,2,1,"","CLOSEST"],[3,2,1,"","LINEAR"],[3,1,1,"","allocate"],[3,1,1,"","allocate_by_tiles"]],"warp.sim":[[4,0,1,"","Model"],[4,0,1,"","ModelBuilder"],[4,0,1,"","SemiImplicitIntegrator"],[4,0,1,"","State"],[4,0,1,"","XPBDIntegrator"]],"warp.sim.Model":[[4,2,1,"","body_com"],[4,2,1,"","body_count"],[4,2,1,"","body_inertia"],[4,1,1,"","collide"],[4,2,1,"","contact_count"],[4,2,1,"","edge_count"],[4,2,1,"","edge_indices"],[4,2,1,"","edge_rest_angle"],[4,1,1,"","flatten"],[4,2,1,"","joint_X_cm"],[4,2,1,"","joint_X_pj"],[4,2,1,"","joint_armature"],[4,2,1,"","joint_axis"],[4,2,1,"","joint_parent"],[4,2,1,"","joint_target"],[4,2,1,"","joint_target_kd"],[4,2,1,"","joint_target_ke"],[4,2,1,"","joint_type"],[4,2,1,"","particle_count"],[4,2,1,"","particle_inv_mass"],[4,2,1,"","particle_mass"],[4,2,1,"","particle_q"],[4,2,1,"","particle_qd"],[4,2,1,"","shape_body"],[4,2,1,"","shape_count"],[4,2,1,"","shape_geo_scale"],[4,2,1,"","shape_geo_src"],[4,2,1,"","shape_geo_type"],[4,2,1,"","shape_materials"],[4,2,1,"","shape_transform"],[4,2,1,"","spring_control"],[4,2,1,"","spring_count"],[4,2,1,"","spring_damping"],[4,2,1,"","spring_indices"],[4,2,1,"","spring_rest_length"],[4,2,1,"","spring_stiffness"],[4,1,1,"","state"],[4,2,1,"","tet_activations"],[4,2,1,"","tet_count"],[4,2,1,"","tet_indices"],[4,2,1,"","tet_materials"],[4,2,1,"","tet_poses"],[4,2,1,"","tri_activations"],[4,2,1,"","tri_count"],[4,2,1,"","tri_indices"],[4,2,1,"","tri_poses"]],"warp.sim.ModelBuilder":[[4,1,1,"","add_body"],[4,1,1,"","add_cloth_grid"],[4,1,1,"","add_cloth_mesh"],[4,1,1,"","add_edge"],[4,1,1,"","add_edges"],[4,1,1,"","add_muscle"],[4,1,1,"","add_particle"],[4,1,1,"","add_rigid_articulation"],[4,1,1,"","add_shape_box"],[4,1,1,"","add_shape_capsule"],[4,1,1,"","add_shape_mesh"],[4,1,1,"","add_shape_plane"],[4,1,1,"","add_shape_sphere"],[4,1,1,"","add_soft_grid"],[4,1,1,"","add_soft_mesh"],[4,1,1,"","add_spring"],[4,1,1,"","add_tetrahedron"],[4,1,1,"","add_triangle"],[4,1,1,"","add_triangles"],[4,1,1,"","compute_box_inertia"],[4,1,1,"","compute_capsule_inertia"],[4,1,1,"","compute_sphere_inertia"],[4,1,1,"","finalize"]],"warp.sim.State":[[4,2,1,"","body_q"],[4,2,1,"","body_qd"],[4,1,1,"","flatten"],[4,2,1,"","particle_q"],[4,2,1,"","particle_qd"]],warp:[[3,0,1,"","HashGrid"],[3,0,1,"","Mesh"],[3,0,1,"","Tape"],[3,0,1,"","Volume"],[1,3,1,"id87","abs"],[1,3,1,"id129","acos"],[1,3,1,"id895","add"],[3,0,1,"","array"],[1,3,1,"id132","asin"],[1,3,1,"id141","atan"],[1,3,1,"id144","atan2"],[1,3,1,"id632","atomic_add"],[1,3,1,"id641","atomic_max"],[1,3,1,"id638","atomic_min"],[1,3,1,"id635","atomic_sub"],[1,3,1,"","bvh_query_aabb"],[1,3,1,"","bvh_query_next"],[1,3,1,"","bvh_query_ray"],[3,3,1,"","capture_begin"],[3,3,1,"","capture_end"],[3,3,1,"","capture_launch"],[1,3,1,"id183","ceil"],[1,3,1,"id76","clamp"],[1,3,1,"","closest_point_edge_edge"],[3,0,1,"","constant"],[1,3,1,"id126","cos"],[1,3,1,"id150","cosh"],[1,3,1,"id261","cross"],[1,3,1,"id803","curlnoise"],[1,3,1,"id464","cw_div"],[1,3,1,"id424","cw_mul"],[1,3,1,"id229","ddot"],[1,3,1,"","degrees"],[1,3,1,"id360","determinant"],[1,3,1,"id384","diag"],[1,3,1,"id1206","div"],[1,3,1,"id211","dot"],[1,3,1,"id507","eig3"],[3,3,1,"","empty"],[3,3,1,"","empty_like"],[1,3,1,"id165","exp"],[1,3,1,"id700","expect_eq"],[1,3,1,"id790","expect_near"],[1,3,1,"id740","expect_neq"],[1,0,1,"","float16"],[1,0,1,"","float32"],[1,0,1,"","float64"],[1,3,1,"id180","floor"],[1,3,1,"id1217","floordiv"],[1,3,1,"","hash_grid_point_id"],[1,3,1,"","hash_grid_query"],[1,3,1,"","hash_grid_query_next"],[1,0,1,"","int16"],[1,0,1,"","int32"],[1,0,1,"","int64"],[1,0,1,"","int8"],[1,3,1,"","intersect_tri_tri"],[1,3,1,"id348","inverse"],[3,3,1,"","launch"],[1,3,1,"id282","length"],[1,3,1,"id302","length_sq"],[1,3,1,"id783","lerp"],[1,3,1,"id156","log"],[1,3,1,"id162","log10"],[1,3,1,"id159","log2"],[1,3,1,"id815","lower_bound"],[1,3,1,"id469","mat"],[1,0,1,"","mat22"],[1,0,1,"","mat22d"],[1,0,1,"","mat22f"],[1,0,1,"","mat22h"],[1,0,1,"","mat33"],[1,0,1,"","mat33d"],[1,0,1,"","mat33f"],[1,0,1,"","mat33h"],[1,0,1,"","mat44"],[1,0,1,"","mat44d"],[1,0,1,"","mat44f"],[1,0,1,"","mat44h"],[1,3,1,"id65","max"],[1,3,1,"","mesh_eval_face_normal"],[1,3,1,"","mesh_eval_position"],[1,3,1,"","mesh_eval_velocity"],[1,3,1,"","mesh_get"],[1,3,1,"","mesh_get_index"],[1,3,1,"","mesh_get_point"],[1,3,1,"","mesh_get_velocity"],[1,3,1,"","mesh_query_aabb"],[1,3,1,"","mesh_query_aabb_next"],[1,3,1,"","mesh_query_point"],[1,3,1,"","mesh_query_ray"],[1,3,1,"id32","min"],[1,3,1,"","mlp"],[1,3,1,"id1161","mod"],[1,3,1,"id1150","mul"],[1,3,1,"id1262","neg"],[1,3,1,"id796","noise"],[1,3,1,"id120","nonzero"],[1,3,1,"id319","normalize"],[1,3,1,"id254","outer"],[1,3,1,"id799","pnoise"],[1,3,1,"id168","pow"],[1,3,1,"","print"],[1,3,1,"","printf"],[1,3,1,"id497","qr3"],[1,0,1,"","quat"],[1,3,1,"id513","quat_from_axis_angle"],[1,3,1,"id523","quat_from_matrix"],[1,3,1,"","quat_identity"],[1,3,1,"id530","quat_inverse"],[1,3,1,"id536","quat_rotate"],[1,3,1,"id542","quat_rotate_inv"],[1,3,1,"id526","quat_rpy"],[1,3,1,"id548","quat_slerp"],[1,3,1,"id519","quat_to_axis_angle"],[1,3,1,"id552","quat_to_matrix"],[1,0,1,"","quatd"],[1,3,1,"id509","quaternion"],[1,0,1,"","quatf"],[1,0,1,"","quath"],[1,3,1,"","radians"],[1,3,1,"id791","rand_init"],[1,3,1,"id793","randf"],[1,3,1,"id792","randi"],[1,3,1,"","randn"],[1,3,1,"id174","rint"],[1,3,1,"id171","round"],[1,3,1,"","sample_cdf"],[1,3,1,"","sample_triangle"],[1,3,1,"","sample_unit_cube"],[1,3,1,"","sample_unit_disk"],[1,3,1,"","sample_unit_hemisphere"],[1,3,1,"","sample_unit_hemisphere_surface"],[1,3,1,"","sample_unit_ring"],[1,3,1,"","sample_unit_sphere"],[1,3,1,"","sample_unit_sphere_surface"],[1,3,1,"","sample_unit_square"],[1,3,1,"","select"],[1,3,1,"id98","sign"],[1,3,1,"id123","sin"],[1,3,1,"id147","sinh"],[1,3,1,"id265","skew"],[1,3,1,"id786","smoothstep"],[1,3,1,"","spatial_adjoint"],[1,3,1,"id626","spatial_bottom"],[1,3,1,"id612","spatial_cross"],[1,3,1,"id618","spatial_cross_dual"],[1,3,1,"id606","spatial_dot"],[1,3,1,"","spatial_jacobian"],[1,3,1,"","spatial_mass"],[1,0,1,"","spatial_matrix"],[1,3,1,"id600","spatial_matrix_t"],[1,0,1,"","spatial_matrixd"],[1,0,1,"","spatial_matrixf"],[1,0,1,"","spatial_matrixh"],[1,3,1,"id622","spatial_top"],[1,0,1,"","spatial_vector"],[1,3,1,"id599","spatial_vector_t"],[1,0,1,"","spatial_vectord"],[1,0,1,"","spatial_vectorf"],[1,0,1,"","spatial_vectorh"],[1,3,1,"id135","sqrt"],[1,3,1,"id109","step"],[1,3,1,"id975","sub"],[1,3,1,"id487","svd3"],[1,3,1,"id138","tan"],[1,3,1,"id153","tanh"],[1,3,1,"id629","tid"],[1,3,1,"id372","trace"],[1,0,1,"","transform"],[1,3,1,"id560","transform_get_rotation"],[1,3,1,"id556","transform_get_translation"],[1,3,1,"","transform_identity"],[1,3,1,"id596","transform_inverse"],[1,3,1,"id566","transform_multiply"],[1,3,1,"id579","transform_point"],[1,3,1,"","transform_t"],[1,3,1,"id592","transform_vector"],[1,0,1,"","transformd"],[1,0,1,"","transformf"],[1,0,1,"","transformh"],[1,3,1,"id336","transpose"],[1,3,1,"id177","trunc"],[1,0,1,"","uint16"],[1,0,1,"","uint32"],[1,0,1,"","uint64"],[1,0,1,"","uint8"],[1,3,1,"","unot"],[1,3,1,"id466","vec"],[1,0,1,"","vec2"],[1,0,1,"","vec2d"],[1,0,1,"","vec2f"],[1,0,1,"","vec2h"],[1,0,1,"","vec2ub"],[1,0,1,"","vec3"],[1,0,1,"","vec3d"],[1,0,1,"","vec3f"],[1,0,1,"","vec3h"],[1,0,1,"","vec3ub"],[1,0,1,"","vec4"],[1,0,1,"","vec4d"],[1,0,1,"","vec4f"],[1,0,1,"","vec4h"],[1,0,1,"","vec4ub"],[1,3,1,"","volume_index_to_world"],[1,3,1,"","volume_index_to_world_dir"],[1,3,1,"","volume_lookup_f"],[1,3,1,"","volume_lookup_i"],[1,3,1,"","volume_lookup_v"],[1,3,1,"","volume_sample_f"],[1,3,1,"","volume_sample_i"],[1,3,1,"","volume_sample_v"],[1,3,1,"","volume_store_f"],[1,3,1,"","volume_store_i"],[1,3,1,"","volume_store_v"],[1,3,1,"","volume_world_to_index"],[1,3,1,"","volume_world_to_index_dir"],[3,3,1,"","zeros"],[3,3,1,"","zeros_like"]]},objnames:{"0":["py","class","Python class"],"1":["py","method","Python method"],"2":["py","attribute","Python attribute"],"3":["py","function","Python function"]},objtypes:{"0":"py:class","1":"py:method","2":"py:attribute","3":"py:function"},terms:{"0":[1,2,3,4],"1":[1,2,3,4],"10":[1,2,3,4],"100":[3,4],"1000":4,"100000":4,"1024":[2,3],"1024x16":3,"128":3,"128x128x3":3,"16":3,"1d":[1,3],"2":[1,2,3,4],"2002":4,"2018":4,"2d":[1,3],"2x2":3,"3":[2,3,4],"32":1,"3d":[1,3],"3x3":[1,3,4],"4":[3,4],"4d":[1,3],"4x4":[1,3],"5":[3,4],"6":3,"60":4,"6d":[1,3],"6x6":[1,3],"7":4,"7d":3,"8x8x8":3,"abstract":3,"boolean":0,"byte":3,"case":[1,3],"class":[1,2,3,4],"default":[0,1,2],"do":[3,4],"enum":3,"export":3,"final":4,"float":[1,2,3,4],"function":[0,1,2,4],"import":[2,3,4],"int":[1,3,4],"long":3,"new":[1,2,3],"return":[1,2,3,4],"short":3,"static":[3,4],"switch":3,"true":[1,3],"try":3,"while":[1,3],A:[1,3,4],By:3,For:[2,3],If:[1,3,4],In:[1,3,4],It:[1,3,4],One:3,The:[1,3,4],Then:4,There:3,These:3,To:[2,3],__array_interface__:3,__cuda_array_interface__:3,ab:1,about:3,abov:[1,3],absolut:1,acceler:3,accept:[3,4],access:[2,3],accumul:3,accustom:3,achiev:2,aco:1,across:4,act:1,activ:[1,3,4],actuat:4,ad:4,add:[1,3,4],add_bodi:4,add_cloth_grid:4,add_cloth_mesh:4,add_edg:4,add_muscl:4,add_particl:4,add_rigid_articul:4,add_shape_box:4,add_shape_capsul:4,add_shape_mesh:4,add_shape_plan:4,add_shape_spher:4,add_soft_grid:4,add_soft_mesh:4,add_spr:4,add_tetrahedron:4,add_triangl:4,addit:3,addition:3,address:3,adj_input:3,adj_output:3,adjoint:3,advanc:[0,4],affin:[1,3],after:[1,3,4],against:[1,3],al:4,alia:[2,3],alias:3,align:[1,3],all:[1,2,3,4],alloc:[2,3],allocate_by_til:3,allow:[1,3],along:[1,3,4],alreadi:3,also:3,altern:[1,3],although:3,alwai:[3,4],an:[1,2,3,4],analog:3,anchor:4,angl:[1,4],ani:[1,2,3],anim:2,annot:2,anoth:[3,4],anyth:4,api:3,appli:[1,3],applic:[2,3],approach:[3,4],appropri:[2,3],ar:[1,2,3,4],arang:3,arbitrari:3,arbitrarili:3,arcco:1,arcsin:1,arctan:1,area:4,arg1:1,arg2:1,arg:1,argument:[1,2,3],arithmet:0,arithmetr:3,armatur:4,around:[1,3,4],arr:1,arrai:[0,1,2,4],array2d:3,array3d:3,articul:4,articulation_build:4,artifici:4,asin:1,assembl:3,assign:3,assum:1,asynchron:[2,3],atan2:1,atan:1,atom:1,atomic_add:[1,3],atomic_max:1,atomic_min:1,atomic_sub:1,attach:3,attribut:[3,4],auto:3,automat:[1,2,4],avail:3,avoid:[2,3],awai:1,axi:[1,3,4],b:[1,2,3,4],back:[2,3],background:1,backpropag:1,backward:3,bary_u:1,bary_v:1,barycentr:[1,3],base:[1,3,4],basi:[1,4],basic:3,batch:[1,3],beam:4,becaus:3,been:[3,4],befor:[1,2,3],begin:3,behav:1,being:3,belong:[2,4],below:[2,3],bend:4,benefit:3,best:[2,3],between:[1,2,3,4],bg_valu:3,bia:1,bigger:3,bit:1,blender:3,block:[1,3],bodi:[1,3,4],body0:4,body_com:4,body_count:4,body_inertia:4,body_q:4,body_qd:4,bool:[1,3,4],bottom:[1,4],bound:[0,1],box:[1,3,4],breakpoint:3,bridson:4,bring:2,bucket:3,buffer:[2,3],bug:3,build:[2,3,4],builder:4,built:[0,3],bvh:[1,3],bvh_query_aabb:1,bvh_query_next:1,bvh_query_rai:1,bvh_query_t:1,byte_arrai:3,c0:[],c1:[],c2:[],c3:[],c4:[],c:[1,2,3,4],c_void_p:3,cach:2,calcul:1,call:[1,3,4],callabl:1,callback:4,can:[1,2,3,4],cannot:[2,3],capabl:3,capac:3,capsul:[3,4],captur:3,capture_begin:3,capture_end:3,capture_launch:3,care:3,cast:[1,3],cdf:1,ceil:1,cell:[3,4],cell_i:4,cell_x:4,cell_z:4,center:4,chain:[3,4],chang:[3,4],check:[0,1],child:4,choos:3,circuit:3,clamp:1,classmethod:3,clear_forc:4,clockwis:4,close:3,closer:1,closest:[1,3],closest_point_edge_edg:1,cloth:4,co:1,code:[2,3],coeffici:4,coher:1,collid:[3,4],collis:4,colloqui:1,color:3,column:1,com:4,combin:1,come:1,common:[3,4],commonli:3,compar:[1,3],comparison:0,compat:3,compil:[0,3],complet:3,complex:3,complex_kernel:3,compon:1,compont:1,compress:3,comput:[1,2,3,4],compute1:3,compute2:3,compute_box_inertia:4,compute_capsule_inertia:4,compute_inertia:[],compute_sphere_inertia:4,concaten:3,concept:3,concret:4,cond:1,condit:3,config:3,configru:4,configur:[3,4],conflict:3,conjug:1,connect:4,consid:1,consol:3,constant:[0,4],constraint:4,construct:[1,2,3,4],constructor:[1,2,3],contact:4,contact_body0:4,contact_body1:4,contact_count:4,contact_dist:4,contact_materi:4,contact_point0:4,contain:[1,3],content:[3,4],context:0,context_ptr:3,contrast:1,control:4,conveni:2,convent:3,convers:0,convert:[1,2,3,4],coordin:[1,3,4],copi:[2,3,4],correct:3,correctli:3,correspond:[1,3],cosh:1,cosin:1,counter:4,cpu:[2,3,4],cpython:2,creat:[3,4],cross:1,ctype:3,cube:[1,3],cubic:1,cucontext:3,cuda:[0,2,4],cumul:1,cupi:0,curl:1,curlnois:1,current:[0,1,4],custom:0,cw_div:1,cw_mul:1,cylind:4,d:[1,3,4],damp:4,data:[0,2,4],datastructur:3,datatyp:3,ddot:1,dealloc:3,debug:0,debugg:3,declar:3,decompos:4,decomposit:1,decor:[2,3],dedupl:3,def:[2,3],defin:[1,2,3,4],definit:[2,3,4],degener:1,degre:1,delet:3,dem:3,dens:3,densiti:4,depend:4,deprec:3,depth:4,deriv:4,describ:[3,4],descript:4,design:[2,3,4],desir:4,dest:2,dest_arrai:3,detail:[0,3],detect:[3,4],determin:1,develop:[],devic:[0,2,4],device_arrai:[2,3],device_array_0:2,device_array_1:2,device_array_2:2,devicelik:3,diag:1,diagnos:3,diagon:[1,3],dictionari:[2,3],differ:[1,2,3],differenti:[0,2,4],difficult:3,dim:[1,2,3],dim_i:[3,4],dim_x:[3,4],dim_z:[3,4],dimens:[1,3],dimension:0,dir:1,direct:[1,3,4],directli:[3,4],discard:1,discret:3,disk:[1,3],dist:3,distanc:[1,3,4],distribut:1,div:1,diverg:1,divis:[1,3],dlpack:3,doe:[1,3,4],doesn:3,domain:3,done:2,dot:[1,2,3],doubl:[1,3],down:3,download:2,driver:3,dt:4,dtype:[2,3],dual:1,dure:[1,3],dynam:[2,3,4],e:[1,2,3,4],each:[1,3,4],easi:[2,3],easili:3,edg:[1,3,4],edge0:1,edge1:1,edge_callback:4,edge_count:4,edge_indic:4,edge_k:4,edge_kd:4,edge_rest_angl:4,effect:3,effici:[3,4],eig3:1,eigen:1,either:[2,3],elast:4,element:[1,3,4],empti:[2,3],empty_lik:3,en:4,enabl:3,enclos:3,encod:[],encount:3,end:3,energi:4,enough:[3,4],ensur:[2,3],entir:3,entri:4,environ:3,epsilon:1,equal:[1,3,4],equat:4,equival:[1,3],error:[1,3],establish:3,et:4,etc:[2,3,4],euler:4,eval:2,evalu:[1,2,3],even:[1,3],everi:[3,4],exact:4,exampl:[0,3,4],example_funct:3,except:[2,3],execut:[2,3],exist:[1,2,3],exit:3,exp:1,expect:[3,4],expect_eq:1,expect_near:1,expect_neq:1,explicit:[3,4],explicitli:[2,3],exponenti:[1,3],expos:[2,3,4],express:[2,3],extens:[2,3],extent:4,extern:3,extract:1,f0:4,f:[1,3],face:[1,3,4],face_callback:4,factor:1,fail:3,fall:3,fals:[1,2,3,4],familiar:3,fast:2,faster:1,featur:[0,1,3],fem:4,field:[1,3],file:3,find:[1,3],fine:3,finit:[],first:[1,2,3,4],fix:[1,3,4],fix_bottom:4,fix_left:4,fix_right:4,fix_top:4,flatten:[1,3,4],flip:4,float16:1,float32:[1,2,3],float64:[1,3],floor:[1,3],floordiv:1,flow:3,fluid:3,fold:3,folder:3,follow:[2,3,4],foo:3,footnot:1,forc:[3,4],form:[1,3,4],format:[1,3],forward:[3,4],found:1,four:4,fourth:4,foward:3,fraction:1,frame:4,framework:[1,2,3],free:[1,3],freeli:3,friction:4,from:[1,2,3,4],from_numpi:2,from_torch:3,front:1,full:[3,4],func:[1,3],fundament:3,futur:[3,4],g:[1,2,3,4],gen:3,gener:[1,2,3,4],geometr:3,geometri:[0,2,3,4],get:[2,3],get_devic:3,give:3,given:[1,3,4],global:[1,2,3],good:2,got:3,gpu:[2,3],grad:3,gradient:[1,3,4],grain:3,graph:[0,4],graphic:[2,3],greater:[1,3],grid:[0,1,4],ground:4,group:4,h:4,ha:[3,4],half:4,half_width:4,halfwai:1,handi:3,handl:3,hard:3,hash:[0,1],hash_grid_point_id:1,hash_grid_queri:[1,3],hash_grid_query_next:[1,3],hash_grid_query_t:1,hashgrid:3,have:[2,3],height:4,help:3,helper:[3,4],hemispher:1,hermit:1,hexahedr:4,hide:3,hierarchi:3,high:2,hint:3,hit:[1,3],hold:4,homogen:1,hood:3,host:[2,3],host_arrai:[2,3],host_array_0:2,host_array_1:2,host_array_2:2,houdini:3,how:3,howev:[2,4],http:4,hx:4,hy:4,hydrodynam:3,hz:4,i:[1,3,4],i_:1,i_m:4,id:[1,3],ident:1,identifi:[1,3],imaginari:1,immut:0,implement:[1,2,3,4],implicit:[3,4],implicit_euler_method:4,impos:3,includ:[2,4],inclus:3,incom:3,incompat:3,incred:3,independ:[3,4],index:[0,1,2,3,4],indic:[1,3,4],individu:3,inerti:1,inertia:[1,3,4],infer:[2,3],inform:3,init:[2,3],initi:[0,1,2,4],input:[1,2,3,4],input_buff:3,input_dim:3,insert:3,insid:[1,3],inspect:3,instal:0,instead:[2,3],instruct:2,int16:[1,3],int32:[1,3],int64:[1,3],int8:[1,3],integ:[1,3],integr:[0,3],intend:4,interact:3,interfac:3,interior:4,intermedi:3,intern:4,interop:0,interoper:3,interpol:[1,3],interpret:3,intersect:1,intersect_tri_tri:1,intrins:1,introduc:3,introduct:0,intuit:1,invalid:2,invers:[1,4],invok:3,involv:3,issu:3,item:1,iter:[1,3,4],its:[1,4],itself:3,ix:1,iy:1,iz:1,j:[1,3,4],j_out:1,j_start:1,jacobian:0,jax:0,jit:2,joint:4,joint_armatur:4,joint_axi:4,joint_count:[1,4],joint_limit_k:4,joint_limit_kd:4,joint_limit_low:4,joint_limit_upp:4,joint_par:[1,4],joint_prismat:4,joint_qd_start:1,joint_revolut:4,joint_start:1,joint_target:4,joint_target_k:4,joint_target_kd:4,joint_typ:4,joint_x_cm:4,joint_x_pj:4,joint_xform:4,joint_xform_child:4,k:[1,3,4],k_:4,k_damp:4,k_lambda:4,k_mu:4,kd:4,ke:4,keep:3,kernel:[0,2],kf:4,kinemat:4,kwarg:3,l:[1,3,4],laid:1,lambda:[2,4],lame:4,languag:0,larg:3,largest:1,latter:3,launch:[0,1,2],launch_kernels_to_be_differenti:3,layer:1,layout:1,lead:3,left:[1,4],length:[1,3,4],length_sq:1,lerp:1,less:[1,3],level:[2,4],li:4,librari:[1,2,3],lie:3,like:[1,3],limit:[3,4],line:3,linear:[1,2,3],linearli:1,list:[2,3,4],littl:3,live:[2,3],lm:4,lmax:4,load:[2,3],load_from_nvdb:3,local:[1,3,4],locat:[1,3,4],log10:1,log2:1,log:1,lookup:3,loop:[3,4],loss:3,low:3,lower:[1,3,4],lower_bound:1,lt:4,m00:[],m01:[],m02:[],m03:[],m10:[],m11:[],m12:[],m13:[],m20:[],m21:[],m22:[],m23:[],m30:[],m31:[],m32:[],m33:[],m:[1,3,4],m_start:1,made:3,magnitud:1,mai:[1,2,3,4],main:2,maintain:[3,4],major:1,make:[2,3,4],manag:[2,3],mani:[3,4],manifold:4,manual:2,map:3,map_cuda_devic:3,marix:1,mark:3,mass:4,mat22:[1,2,3],mat22d:1,mat22f:1,mat22h:1,mat33:[1,2,3],mat33d:1,mat33f:1,mat33h:1,mat44:[1,2,3],mat44d:1,mat44f:1,mat44h:1,mat:1,match:3,materi:4,math:[0,2,3],mathbb:3,mathbf:3,matric:[1,3],matrix33:2,matrix:[1,3],matrix_t:1,max:[1,3],max_dist:1,max_t:1,maxim:4,maximum:[1,3],md:2,mean:[3,4],mechan:3,memori:[0,1,3,4],mesh:[0,1,4],mesh_eval_face_norm:1,mesh_eval_posit:1,mesh_eval_veloc:1,mesh_get:1,mesh_get_index:1,mesh_get_point:1,mesh_get_veloc:1,mesh_query_aabb:1,mesh_query_aabb_next:1,mesh_query_aabb_t:1,mesh_query_point:1,mesh_query_rai:[1,3],method:[1,3,4],min:[1,3],minim:3,minimum:1,mlp:1,mod:1,mode:3,model:0,modelbuild:4,modifi:3,modul:[0,2,3,4],modulu:3,moller:1,more:[1,3],most:[1,3,4],move:[1,3],mu:4,mul:1,multi:[0,1],multipl:[2,3],multipli:1,muscl:4,must:[1,2,3],mutat:[2,3],mygrid:3,n:[1,2,3],name:3,nanovdb:3,narrow:3,nativ:3,natur:1,ndarrai:3,ndim:3,nearest:[1,3],need:[2,3],neg:1,neighbor:[1,3],neohookean:4,nest:3,network:1,next:1,node:4,nois:1,non:[1,3,4],none:[1,3,4],nonzero:1,normal:[1,3],notabl:1,notat:2,note:[1,2,3],np:[2,3],num_env:3,numba:0,number:[1,2,3,4],numer:3,numpi:[0,1,2],nvdb:3,object:[1,3,4],obtain:4,occur:[1,3],offer:3,offset:1,often:[2,3],omit:3,onc:[3,4],one:[2,3,4],ones:2,onli:[1,3,4],onto:[1,2,3],open:3,openvdb:3,oper:[0,2],oppos:4,option:[1,3,4],order:[1,3],ordin:3,org:4,orient:4,origin:[3,4],orthogon:1,other:[0,3],otherwis:[1,3],ouput_dim:3,out:[1,3],outer:1,output:[1,2,3,4],output_buff:3,output_dim:3,output_index:3,outsid:3,outstand:3,over:[1,3],overhead:3,overlap:[1,3],overrid:4,overwrit:3,own:[3,4],owner:3,p1:1,p2:1,p:[1,3],packag:2,page:0,pair:4,parallel:[1,3],param:[],paramet:[1,2,3,4],paramt:4,parent:4,part:[1,3],particip:3,particl:[3,4],particle_count:4,particle_inv_mass:4,particle_mass:4,particle_q:4,particle_qd:4,particularli:3,pass:[1,3],path:3,pattern:2,pd:4,pelas:4,pen:4,per:[1,3,4],perceptron:1,perform:[2,3,4],period:1,perlin:1,physic:[2,4],pin:3,pipelin:3,pitch:1,place:4,planar:4,plane:[1,4],pleas:[2,3],pnois:1,po:[1,4],point:[1,3,4],pointer:3,points_in_world_spac:3,poorli:3,popular:3,pose:4,posit:[1,3,4],possibl:[2,3,4],pow:1,power:1,pre:2,precis:3,precomput:3,preserv:[1,4],previou:3,previous:3,primari:3,print:[0,1],print_launch:3,printf:[1,3],problem:3,problemat:3,procedur:2,process:[1,2,3],product:[1,2,3],program:[1,2,3],progress:4,propag:[3,4],protocol:3,provid:3,pt:1,ptr:3,ptx:2,put:3,px:1,py:1,python:[2,3,4],pytorch:[0,1,2],pz:1,q0:1,q1:1,q2:1,q:[1,2,3],q_grad_i:3,qr3:1,qr:1,quantiti:[],quarternion:1,quat:[1,2,3],quat_from_axis_angl:1,quat_from_matrix:1,quat_ident:1,quat_invers:1,quat_rot:1,quat_rotate_inv:1,quat_rpi:1,quat_slerp:1,quat_to_axis_angl:1,quat_to_matrix:1,quatd:1,quaternion:[0,2,3],quatf:1,quath:1,queri:[1,3],queu:2,r:[1,2,3,4],radian:[1,4],radiu:[1,3,4],rai:[1,3],rais:[1,3],rand:3,rand_init:1,randf:1,randi:1,randn:1,random:[0,3],rang:[1,3,4],rapidli:4,rather:[2,4],ray_dir:3,ray_hit:3,ray_origin:3,raycast:3,rb:3,re:[1,3],read:[2,3],readi:4,readm:2,real:[1,3],reason:3,rebuild:3,recommend:[3,4],record:3,rectangular:4,recurs:2,redund:3,refer:[0,2],refit:3,regard:3,regist:[2,3],regular:4,rel:4,relax:4,repeat:3,replai:3,repres:[1,3,4],represent:4,request:3,requir:[3,4],requires_grad:[3,4],reshap:3,resid:3,resourc:3,respect:[3,4],respons:3,rest:4,restart:2,restor:3,restrict:3,result:[1,2,3],retriev:[1,3],retrun:1,returend:1,reus:3,revers:3,reverse_wind:4,right:[1,4],rigid:[1,3,4],ring:1,rint:1,rng:1,robust:1,roll:1,root:4,rot:[1,4],rotat:[1,4],rotate_rodriguez:[],round:[1,3],row:[1,3],run:3,runtim:[0,2,4],s0:1,s10:1,s11:1,s12:1,s13:1,s14:1,s15:1,s16:1,s17:1,s18:1,s19:1,s1:1,s20:1,s21:1,s22:1,s23:1,s24:1,s25:1,s26:1,s27:1,s28:1,s29:1,s2:1,s30:1,s31:1,s32:1,s33:1,s34:1,s35:1,s3:1,s4:1,s5:1,s6:1,s7:1,s8:1,s9:1,s:[1,3,4],safe:3,same:[1,2,3],sampl:[1,3],sample_cdf:1,sample_grid:3,sample_triangl:1,sample_unit_cub:1,sample_unit_disk:1,sample_unit_hemispher:1,sample_unit_hemisphere_surfac:1,sample_unit_r:1,sample_unit_spher:1,sample_unit_sphere_surfac:1,sample_unit_squar:1,sampling_mod:1,scalar:0,scale:[1,3,4],scene:4,scope:0,scopeddevic:3,screw:1,script:3,sdf:3,search:[0,1],second:[1,3,4],secondari:3,section:4,see:[2,3,4],seed:1,select:[1,3],select_index:3,semant:2,semi:4,semiimplicitintegr:4,sens:[1,3],separ:3,sequenc:2,sequenti:3,seri:3,serial:3,set:[1,2,3,4],set_devic:3,shade:2,shape:[2,3,4],shape_bodi:4,shape_count:4,shape_geo_scal:4,shape_geo_src:4,shape_geo_typ:4,shape_materi:4,shape_t:[],shape_transform:4,share:[1,2,3],sheet:4,should:[1,2,3,4],show:3,shown:3,side:3,sigma:1,sign:[1,3],signatur:[2,3],signific:3,silent:3,sim:4,similar:[1,2,3],simpl:3,simple_kernel:[2,3],simpli:3,simplifi:3,simul:[0,2,3],sin:1,sinc:[3,4],sine:1,singl:[1,3,4],singular:1,sinh:1,size:3,skew:1,slice:[2,3],slower:1,small:4,smallest:[1,3],smallmatrix:3,smith:4,smooth:3,smoothli:1,smoothstep:1,snippet:3,so:[2,3,4],softwar:3,solid:4,some:[1,2,3],sort:1,sourc:[2,3,4],space:[1,3,4],spars:3,spatial:[0,3],spatial_adjoint:1,spatial_bottom:[1,3],spatial_cross:1,spatial_cross_du:1,spatial_dot:1,spatial_jacobian:1,spatial_mass:1,spatial_matrix:[1,3],spatial_matrix_t:1,spatial_matrixd:1,spatial_matrixf:1,spatial_matrixh:1,spatial_top:[1,3],spatial_vector:[1,3],spatial_vector_t:1,spatial_vectord:1,spatial_vectorf:1,spatial_vectorh:1,specfi:4,special:3,specif:3,specifi:[1,2,3,4],sph:3,sphere:[1,3,4],spring:4,spring_control:4,spring_count:4,spring_damp:4,spring_indic:4,spring_rest_length:4,spring_stiff:4,sqrt:1,squar:[1,3],src:[2,3],src_arrai:3,stabl:4,standard:[3,4],start:[1,3],startup:2,state:[0,1,2,3],state_in:4,state_out:4,stdout:1,step:[0,1,4],stiff:4,still:3,storag:3,store:[1,2,3,4],str:3,stream:3,strict:3,strictli:3,stride:3,string:[1,3],strong:0,strongli:[2,4],structur:[2,3,4],studio:3,style:[1,3],sub:1,subject:4,subsequ:3,subtract:[1,3],success:3,suit:3,sum:3,support:[2,3,4],surfac:[1,4],surpris:3,suspect:3,svd3:1,svd:1,symbol:3,symmetr:1,symplect:4,synchron:[0,2],synchronize_devic:3,syntax:[1,2,3],system:[3,4],t:[1,3,4],take:[1,3],tan:1,tangent:1,tanh:1,tape:3,target:[3,4],templat:3,temporari:[2,3],tendon:4,tensor:[3,4],test:[1,3],tet_activ:4,tet_count:4,tet_indic:4,tet_materi:4,tet_pos:4,tetrahdera:4,tetrahedr:4,tetrahedra:4,tetrahedron:4,tetrhedra:4,than:[1,2,3,4],thei:[3,4],them:3,themselv:3,therefor:3,thi:[1,2,3,4],thing:3,third:4,those:3,thread:[1,2,3],three:[1,4],through:0,tid:[1,2,3],tile:3,tile_point:3,time:[2,3,4],to_torch:3,togeth:[1,2],toler:1,tool:3,top:[1,3,4],topolog:3,torch:3,total:4,tr:1,trace:1,track:[1,3],tranform:1,transfer:[2,3,4],transform:[0,3,4],transform_class:1,transform_get_rot:1,transform_get_transl:1,transform_ident:1,transform_invers:1,transform_multipli:1,transform_point:1,transform_t:1,transform_vector:1,transformd:1,transformf:1,transformh:1,translat:[1,3],transpos:1,travers:1,treat:[1,3,4],tri_activ:4,tri_count:4,tri_drag:4,tri_indic:4,tri_k:4,tri_ka:4,tri_kb:4,tri_kd:4,tri_lift:4,tri_pos:4,triangl:[1,3,4],trianglular:4,triangular:1,trigger:2,trilinear:3,trunc:1,tupl:[1,2,3,4],twice:3,twist:[1,3],two:[1,2,3,4],type:[0,4],type_capsul:3,type_cub:3,type_spher:3,typic:[1,3],u0:1,u1:1,u2:1,u:[1,3],uint16:[1,3],uint32:[1,3],uint64:[1,3],uint8:[1,3],unalloc:3,uncompress:3,uncondition:4,uncorrel:1,under:[3,4],underli:[2,3],understand:3,uniformli:1,uniniti:3,uninitiz:2,union:3,uniqu:3,unit:[1,3,4],unlik:2,unot:1,unpredict:3,unrol:3,unsign:3,unsupport:0,up:3,updat:[1,3,4],upper:[1,3,4],us:[1,2,3,4],usag:[0,1,3],usd:1,user:[0,1,2,4],util:0,uvw:1,v0:1,v1:1,v2:1,v:[1,2,3],valid:[2,3],valu:[0,1,2,4],vari:4,variabl:[1,2,3],variat:4,variou:3,vdb:3,vec2:[1,2,3],vec2d:1,vec2f:1,vec2h:1,vec2ub:1,vec3:[1,2,3,4],vec3d:1,vec3f:1,vec3h:1,vec3ub:1,vec4:[1,2,3],vec4d:1,vec4f:1,vec4h:1,vec4ub:1,vec:1,vector:[0,2],vector_t:1,vel:4,veloc:[1,3,4],velocit:1,veri:3,verif:0,verifi:3,verify_cuda:3,version:3,vertex:[1,3,4],vertic:4,via:[2,3],view:[2,3],violat:3,viscoelast:4,visibl:2,visual:3,volum:[0,4],volume_index_to_world:1,volume_index_to_world_dir:1,volume_lookup_f:1,volume_lookup_i:1,volume_lookup_v:1,volume_sample_f:[1,3],volume_sample_i:1,volume_sample_v:1,volume_store_f:1,volume_store_i:1,volume_store_v:1,volume_world_to_index:[1,3],volume_world_to_index_dir:1,volumetr:[3,4],voxel:[1,3],voxel_s:3,w:[1,3,4],wa:3,wai:[1,3],wait:3,want:3,warp:[1,2,3,4],watertight:1,waypoint:4,we:[2,3],weight:1,well:[1,3],what:3,when:[1,3,4],where:[1,2,3],whether:3,which:[1,2,3,4],whole:1,width:[3,4],wiki:4,wikipedia:4,wind:4,wise:1,wish:3,within:3,withing:1,word:1,work:[3,4],workflow:3,world:[1,3,4],would:3,wp:[1,2,3,4],wrap:2,wrapper:3,wrench:1,write:[2,3],written:3,x:[1,2,3,4],xform:4,xpbd:4,xpbdintegr:4,xy:1,xyz:1,xyzt:1,y:[1,2,3,4],yaw:1,you:3,your:4,z:[1,3,4],zero:[1,2,3,4],zeros_lik:3,zip:3},titles:["NVIDIA Warp Documentation","Kernel Reference","Introduction","Runtime Reference","Simulation Reference"],titleterms:{"boolean":3,"default":3,"function":3,advanc:3,arithmet:3,arrai:3,bound:3,built:2,check:3,comparison:3,compil:2,constant:3,content:0,context:3,convers:3,cuda:3,cupi:3,current:3,custom:3,data:3,debug:3,detail:2,devic:3,differenti:3,dimension:3,document:0,exampl:2,featur:2,geometri:1,graph:3,grid:3,hash:3,immut:2,indic:0,initi:3,instal:2,integr:4,interop:3,introduct:2,jacobian:3,jax:3,kernel:[1,3],languag:2,launch:3,math:1,memori:2,mesh:3,model:[2,4],multi:3,numba:3,numpi:3,nvidia:0,oper:[1,3],other:1,print:3,pytorch:3,quaternion:1,random:1,refer:[1,3,4],runtim:3,scalar:[1,3],scope:3,simul:4,spatial:1,state:4,step:3,strong:2,synchron:3,tabl:0,through:3,todo:4,transform:1,type:[1,2,3],unsupport:2,usag:2,user:3,util:1,valu:3,vector:[1,3],verif:3,volum:[1,3],warp:0}}) \ No newline at end of file +Search.setIndex({docnames:["index","modules/functions","modules/introduction","modules/runtime","modules/sim"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":5,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.intersphinx":1,"sphinx.ext.todo":2,sphinx:56},filenames:["index.rst","modules\\functions.rst","modules\\introduction.rst","modules\\runtime.rst","modules\\sim.rst"],objects:{"warp.HashGrid":[[3,1,1,"","build"],[3,2,1,"","device"],[3,2,1,"","id"]],"warp.Mesh":[[3,2,1,"","device"],[3,2,1,"","id"],[3,1,1,"","refit"]],"warp.Volume":[[3,2,1,"","CLOSEST"],[3,2,1,"","LINEAR"],[3,1,1,"","allocate"],[3,1,1,"","allocate_by_tiles"]],"warp.sim":[[4,0,1,"","Model"],[4,0,1,"","ModelBuilder"],[4,0,1,"","SemiImplicitIntegrator"],[4,0,1,"","State"],[4,0,1,"","XPBDIntegrator"]],"warp.sim.Model":[[4,2,1,"","body_com"],[4,2,1,"","body_count"],[4,2,1,"","body_inertia"],[4,1,1,"","collide"],[4,2,1,"","contact_count"],[4,2,1,"","edge_count"],[4,2,1,"","edge_indices"],[4,2,1,"","edge_rest_angle"],[4,1,1,"","flatten"],[4,2,1,"","joint_X_cm"],[4,2,1,"","joint_X_pj"],[4,2,1,"","joint_armature"],[4,2,1,"","joint_axis"],[4,2,1,"","joint_parent"],[4,2,1,"","joint_target"],[4,2,1,"","joint_target_kd"],[4,2,1,"","joint_target_ke"],[4,2,1,"","joint_type"],[4,2,1,"","particle_count"],[4,2,1,"","particle_inv_mass"],[4,2,1,"","particle_mass"],[4,2,1,"","particle_q"],[4,2,1,"","particle_qd"],[4,2,1,"","shape_body"],[4,2,1,"","shape_count"],[4,2,1,"","shape_geo_scale"],[4,2,1,"","shape_geo_src"],[4,2,1,"","shape_geo_type"],[4,2,1,"","shape_materials"],[4,2,1,"","shape_transform"],[4,2,1,"","spring_control"],[4,2,1,"","spring_count"],[4,2,1,"","spring_damping"],[4,2,1,"","spring_indices"],[4,2,1,"","spring_rest_length"],[4,2,1,"","spring_stiffness"],[4,1,1,"","state"],[4,2,1,"","tet_activations"],[4,2,1,"","tet_count"],[4,2,1,"","tet_indices"],[4,2,1,"","tet_materials"],[4,2,1,"","tet_poses"],[4,2,1,"","tri_activations"],[4,2,1,"","tri_count"],[4,2,1,"","tri_indices"],[4,2,1,"","tri_poses"]],"warp.sim.ModelBuilder":[[4,1,1,"","add_body"],[4,1,1,"","add_cloth_grid"],[4,1,1,"","add_cloth_mesh"],[4,1,1,"","add_edge"],[4,1,1,"","add_edges"],[4,1,1,"","add_muscle"],[4,1,1,"","add_particle"],[4,1,1,"","add_rigid_articulation"],[4,1,1,"","add_shape_box"],[4,1,1,"","add_shape_capsule"],[4,1,1,"","add_shape_mesh"],[4,1,1,"","add_shape_plane"],[4,1,1,"","add_shape_sphere"],[4,1,1,"","add_soft_grid"],[4,1,1,"","add_soft_mesh"],[4,1,1,"","add_spring"],[4,1,1,"","add_tetrahedron"],[4,1,1,"","add_triangle"],[4,1,1,"","add_triangles"],[4,1,1,"","compute_box_inertia"],[4,1,1,"","compute_capsule_inertia"],[4,1,1,"","compute_sphere_inertia"],[4,1,1,"","finalize"]],"warp.sim.State":[[4,2,1,"","body_q"],[4,2,1,"","body_qd"],[4,1,1,"","flatten"],[4,2,1,"","particle_q"],[4,2,1,"","particle_qd"]],warp:[[3,0,1,"","HashGrid"],[3,0,1,"","Mesh"],[3,0,1,"","Tape"],[3,0,1,"","Volume"],[1,3,1,"id87","abs"],[1,3,1,"id129","acos"],[1,3,1,"id895","add"],[3,0,1,"","array"],[1,3,1,"id132","asin"],[1,3,1,"id141","atan"],[1,3,1,"id144","atan2"],[1,3,1,"id632","atomic_add"],[1,3,1,"id641","atomic_max"],[1,3,1,"id638","atomic_min"],[1,3,1,"id635","atomic_sub"],[1,3,1,"","bvh_query_aabb"],[1,3,1,"","bvh_query_next"],[1,3,1,"","bvh_query_ray"],[3,3,1,"","capture_begin"],[3,3,1,"","capture_end"],[3,3,1,"","capture_launch"],[1,3,1,"id183","ceil"],[1,3,1,"id76","clamp"],[1,3,1,"","closest_point_edge_edge"],[3,0,1,"","constant"],[1,3,1,"id126","cos"],[1,3,1,"id150","cosh"],[1,3,1,"id261","cross"],[1,3,1,"id803","curlnoise"],[1,3,1,"id464","cw_div"],[1,3,1,"id424","cw_mul"],[1,3,1,"id229","ddot"],[1,3,1,"","degrees"],[1,3,1,"id360","determinant"],[1,3,1,"id384","diag"],[1,3,1,"id1206","div"],[1,3,1,"id211","dot"],[1,3,1,"id507","eig3"],[3,3,1,"","empty"],[3,3,1,"","empty_like"],[1,3,1,"id165","exp"],[1,3,1,"id700","expect_eq"],[1,3,1,"id790","expect_near"],[1,3,1,"id740","expect_neq"],[1,0,1,"","float16"],[1,0,1,"","float32"],[1,0,1,"","float64"],[1,3,1,"id180","floor"],[1,3,1,"id1217","floordiv"],[1,3,1,"","hash_grid_point_id"],[1,3,1,"","hash_grid_query"],[1,3,1,"","hash_grid_query_next"],[1,0,1,"","int16"],[1,0,1,"","int32"],[1,0,1,"","int64"],[1,0,1,"","int8"],[1,3,1,"","intersect_tri_tri"],[1,3,1,"id348","inverse"],[3,3,1,"","launch"],[1,3,1,"id282","length"],[1,3,1,"id302","length_sq"],[1,3,1,"id783","lerp"],[1,3,1,"id156","log"],[1,3,1,"id162","log10"],[1,3,1,"id159","log2"],[1,3,1,"id815","lower_bound"],[1,3,1,"id469","mat"],[1,0,1,"","mat22"],[1,0,1,"","mat22d"],[1,0,1,"","mat22f"],[1,0,1,"","mat22h"],[1,0,1,"","mat33"],[1,0,1,"","mat33d"],[1,0,1,"","mat33f"],[1,0,1,"","mat33h"],[1,0,1,"","mat44"],[1,0,1,"","mat44d"],[1,0,1,"","mat44f"],[1,0,1,"","mat44h"],[1,3,1,"id65","max"],[1,3,1,"","mesh_eval_face_normal"],[1,3,1,"","mesh_eval_position"],[1,3,1,"","mesh_eval_velocity"],[1,3,1,"","mesh_get"],[1,3,1,"","mesh_get_index"],[1,3,1,"","mesh_get_point"],[1,3,1,"","mesh_get_velocity"],[1,3,1,"","mesh_query_aabb"],[1,3,1,"","mesh_query_aabb_next"],[1,3,1,"","mesh_query_point"],[1,3,1,"","mesh_query_ray"],[1,3,1,"id32","min"],[1,3,1,"","mlp"],[1,3,1,"id1161","mod"],[1,3,1,"id1150","mul"],[1,3,1,"id1262","neg"],[1,3,1,"id796","noise"],[1,3,1,"id120","nonzero"],[1,3,1,"id319","normalize"],[1,3,1,"id254","outer"],[1,3,1,"id799","pnoise"],[1,3,1,"id168","pow"],[1,3,1,"","print"],[1,3,1,"","printf"],[1,3,1,"id497","qr3"],[1,0,1,"","quat"],[1,3,1,"id513","quat_from_axis_angle"],[1,3,1,"id523","quat_from_matrix"],[1,3,1,"","quat_identity"],[1,3,1,"id530","quat_inverse"],[1,3,1,"id536","quat_rotate"],[1,3,1,"id542","quat_rotate_inv"],[1,3,1,"id526","quat_rpy"],[1,3,1,"id548","quat_slerp"],[1,3,1,"id519","quat_to_axis_angle"],[1,3,1,"id552","quat_to_matrix"],[1,0,1,"","quatd"],[1,3,1,"id509","quaternion"],[1,0,1,"","quatf"],[1,0,1,"","quath"],[1,3,1,"","radians"],[1,3,1,"id791","rand_init"],[1,3,1,"id793","randf"],[1,3,1,"id792","randi"],[1,3,1,"","randn"],[1,3,1,"id174","rint"],[1,3,1,"id171","round"],[1,3,1,"","sample_cdf"],[1,3,1,"","sample_triangle"],[1,3,1,"","sample_unit_cube"],[1,3,1,"","sample_unit_disk"],[1,3,1,"","sample_unit_hemisphere"],[1,3,1,"","sample_unit_hemisphere_surface"],[1,3,1,"","sample_unit_ring"],[1,3,1,"","sample_unit_sphere"],[1,3,1,"","sample_unit_sphere_surface"],[1,3,1,"","sample_unit_square"],[1,3,1,"","select"],[1,3,1,"id98","sign"],[1,3,1,"id123","sin"],[1,3,1,"id147","sinh"],[1,3,1,"id265","skew"],[1,3,1,"id786","smoothstep"],[1,3,1,"","spatial_adjoint"],[1,3,1,"id626","spatial_bottom"],[1,3,1,"id612","spatial_cross"],[1,3,1,"id618","spatial_cross_dual"],[1,3,1,"id606","spatial_dot"],[1,3,1,"","spatial_jacobian"],[1,3,1,"","spatial_mass"],[1,0,1,"","spatial_matrix"],[1,3,1,"id600","spatial_matrix_t"],[1,0,1,"","spatial_matrixd"],[1,0,1,"","spatial_matrixf"],[1,0,1,"","spatial_matrixh"],[1,3,1,"id622","spatial_top"],[1,0,1,"","spatial_vector"],[1,3,1,"id599","spatial_vector_t"],[1,0,1,"","spatial_vectord"],[1,0,1,"","spatial_vectorf"],[1,0,1,"","spatial_vectorh"],[1,3,1,"id135","sqrt"],[1,3,1,"id109","step"],[1,3,1,"id975","sub"],[1,3,1,"id487","svd3"],[1,3,1,"id138","tan"],[1,3,1,"id153","tanh"],[1,3,1,"id629","tid"],[1,3,1,"id372","trace"],[1,0,1,"","transform"],[1,3,1,"id560","transform_get_rotation"],[1,3,1,"id556","transform_get_translation"],[1,3,1,"","transform_identity"],[1,3,1,"id596","transform_inverse"],[1,3,1,"id566","transform_multiply"],[1,3,1,"id579","transform_point"],[1,3,1,"","transform_t"],[1,3,1,"id592","transform_vector"],[1,0,1,"","transformd"],[1,0,1,"","transformf"],[1,0,1,"","transformh"],[1,3,1,"id336","transpose"],[1,3,1,"id177","trunc"],[1,0,1,"","uint16"],[1,0,1,"","uint32"],[1,0,1,"","uint64"],[1,0,1,"","uint8"],[1,3,1,"","unot"],[1,3,1,"id466","vec"],[1,0,1,"","vec2"],[1,0,1,"","vec2d"],[1,0,1,"","vec2f"],[1,0,1,"","vec2h"],[1,0,1,"","vec2ub"],[1,0,1,"","vec3"],[1,0,1,"","vec3d"],[1,0,1,"","vec3f"],[1,0,1,"","vec3h"],[1,0,1,"","vec3ub"],[1,0,1,"","vec4"],[1,0,1,"","vec4d"],[1,0,1,"","vec4f"],[1,0,1,"","vec4h"],[1,0,1,"","vec4ub"],[1,3,1,"","volume_index_to_world"],[1,3,1,"","volume_index_to_world_dir"],[1,3,1,"","volume_lookup_f"],[1,3,1,"","volume_lookup_i"],[1,3,1,"","volume_lookup_v"],[1,3,1,"","volume_sample_f"],[1,3,1,"","volume_sample_i"],[1,3,1,"","volume_sample_v"],[1,3,1,"","volume_store_f"],[1,3,1,"","volume_store_i"],[1,3,1,"","volume_store_v"],[1,3,1,"","volume_world_to_index"],[1,3,1,"","volume_world_to_index_dir"],[3,3,1,"","zeros"],[3,3,1,"","zeros_like"]]},objnames:{"0":["py","class","Python class"],"1":["py","method","Python method"],"2":["py","attribute","Python attribute"],"3":["py","function","Python function"]},objtypes:{"0":"py:class","1":"py:method","2":"py:attribute","3":"py:function"},terms:{"0":[1,2,3,4],"1":[1,2,3,4],"10":[1,2,3,4],"100":[3,4],"1000":4,"100000":4,"1024":[2,3],"1024x16":3,"128":3,"128x128x3":3,"16":3,"1d":[1,3],"2":[1,2,3,4],"2002":4,"2018":4,"2d":[1,3],"2x2":3,"3":[1,2,3,4],"32":1,"3d":[1,3],"3x3":[1,3,4],"4":[1,3,4],"4d":[1,3],"4x4":[1,3],"5":[3,4],"6":3,"60":4,"6d":[1,3],"6x6":[1,3],"7":4,"7d":3,"8x8x8":3,"abstract":3,"boolean":0,"byte":3,"case":[1,3],"class":[1,2,3,4],"default":[0,1,2],"do":[3,4],"enum":3,"export":3,"final":4,"float":[1,2,3,4],"function":[0,1,2,4],"import":[2,3,4],"int":[1,3,4],"long":3,"new":[1,2,3],"return":[1,2,3,4],"short":3,"static":[3,4],"switch":3,"true":[1,3],"try":3,"while":[1,3],A:[1,3,4],By:3,For:[2,3],If:[1,3,4],In:[1,3,4],It:[1,3,4],One:3,The:[1,3,4],Then:4,There:3,These:3,To:[2,3],__array_interface__:3,__cuda_array_interface__:3,ab:1,about:3,abov:[1,3],absolut:1,acceler:3,accept:[3,4],access:[2,3],accumul:3,accustom:3,achiev:2,aco:1,across:4,act:1,activ:[1,3,4],actuat:4,ad:4,add:[1,3,4],add_bodi:4,add_cloth_grid:4,add_cloth_mesh:4,add_edg:4,add_muscl:4,add_particl:4,add_rigid_articul:4,add_shape_box:4,add_shape_capsul:4,add_shape_mesh:4,add_shape_plan:4,add_shape_spher:4,add_soft_grid:4,add_soft_mesh:4,add_spr:4,add_tetrahedron:4,add_triangl:4,addit:3,addition:3,address:3,adj_input:3,adj_output:3,adjoint:3,advanc:[0,4],affin:[1,3],after:[1,3,4],against:[1,3],al:4,alia:[2,3],alias:3,align:[1,3],all:[1,2,3,4],alloc:[2,3],allocate_by_til:3,allow:[1,3],along:[1,3,4],alreadi:3,also:3,altern:[1,3],although:3,alwai:[3,4],an:[1,2,3,4],analog:3,anchor:4,angl:[1,4],ani:[1,2,3],anim:2,annot:2,anoth:[3,4],anyth:4,api:3,appli:[1,3],applic:[2,3],approach:[3,4],appropri:[2,3],ar:[1,2,3,4],arang:3,arbitrari:3,arbitrarili:3,arcco:1,arcsin:1,arctan:1,area:4,arg1:1,arg2:1,arg:1,argument:[1,2,3],arithmet:0,arithmetr:3,armatur:4,around:[1,3,4],arr:1,arrai:[0,1,2,4],array2d:3,array3d:3,articul:4,articulation_build:4,artifici:4,asin:1,assembl:3,assign:3,assum:1,asynchron:[2,3],atan2:1,atan:1,atom:1,atomic_add:[1,3],atomic_max:1,atomic_min:1,atomic_sub:1,attach:3,attribut:[3,4],auto:3,automat:[1,2,4],avail:3,avoid:[2,3],awai:1,axi:[1,3,4],b:[1,2,3,4],back:[2,3],background:1,backpropag:1,backward:3,bary_u:1,bary_v:1,barycentr:[1,3],base:[1,3,4],basi:[1,4],basic:3,batch:[1,3],beam:4,becaus:3,been:[3,4],befor:[1,2,3],begin:3,behav:1,being:3,belong:[2,4],below:[2,3],bend:4,benefit:3,best:[2,3],between:[1,2,3,4],bg_valu:3,bia:1,bigger:3,bit:1,blender:3,block:[1,3],bodi:[1,3,4],body0:4,body_com:4,body_count:4,body_inertia:4,body_q:4,body_qd:4,bool:[1,3,4],bottom:[1,4],bound:[0,1],box:[1,3,4],breakpoint:3,bridson:4,bring:2,bucket:3,buffer:[2,3],bug:3,build:[2,3,4],builder:4,built:[0,3],bvh:[1,3],bvh_query_aabb:1,bvh_query_next:1,bvh_query_rai:1,bvh_query_t:1,byte_arrai:3,c0:[],c1:[],c2:[],c3:[],c4:[],c:[1,2,3,4],c_void_p:3,cach:2,calcul:1,call:[1,3,4],callabl:1,callback:4,can:[1,2,3,4],cannot:[2,3],capabl:3,capac:3,capsul:[3,4],captur:3,capture_begin:3,capture_end:3,capture_launch:3,care:3,cast:[1,3],cdf:1,ceil:1,cell:[3,4],cell_i:4,cell_x:4,cell_z:4,center:4,chain:[3,4],chang:[3,4],check:[0,1],child:4,choos:3,circuit:3,clamp:1,classmethod:3,clear_forc:4,clockwis:4,close:3,closer:1,closest:[1,3],closest_point_edge_edg:1,cloth:4,co:1,code:[2,3],coeffici:4,coher:1,collid:[3,4],collis:4,colloqui:1,color:3,column:1,com:4,combin:1,come:1,common:[3,4],commonli:3,compar:[1,3],comparison:0,compat:3,compil:[0,3],complet:3,complex:3,complex_kernel:3,compon:1,compont:1,compress:3,comput:[1,2,3,4],compute1:3,compute2:3,compute_box_inertia:4,compute_capsule_inertia:4,compute_inertia:[],compute_sphere_inertia:4,concaten:3,concept:3,concret:4,cond:1,condit:3,config:3,configru:4,configur:[3,4],conflict:3,conjug:1,connect:4,consid:1,consol:3,constant:[0,4],constraint:4,construct:[1,2,3,4],constructor:[1,2,3],contact:4,contact_body0:4,contact_body1:4,contact_count:4,contact_dist:4,contact_materi:4,contact_point0:4,contain:[1,3],content:[3,4],context:0,context_ptr:3,contrast:1,control:4,conveni:2,convent:3,convers:0,convert:[1,2,3,4],coordin:[1,3,4],copi:[2,3,4],correct:3,correctli:3,correspond:[1,3],cosh:1,cosin:1,counter:4,cpu:[2,3,4],cpython:2,creat:[3,4],cross:1,ctype:3,cube:[1,3],cubic:1,cucontext:3,cuda:[0,2,4],cumul:1,cupi:0,curl:1,curlnois:1,current:[0,1,4],custom:0,cw_div:1,cw_mul:1,cylind:4,d:[1,3,4],damp:4,data:[0,2,4],datastructur:3,datatyp:3,ddot:1,dealloc:3,debug:0,debugg:3,declar:3,decompos:4,decomposit:1,decor:[2,3],dedupl:3,def:[2,3],defin:[1,2,3,4],definit:[2,3,4],degener:1,degre:1,delet:3,dem:3,dens:3,densiti:4,depend:4,deprec:3,depth:4,deriv:4,describ:[3,4],descript:4,design:[2,3,4],desir:4,dest:2,dest_arrai:3,detail:[0,3],detect:[3,4],determin:1,develop:[],devic:[0,2,4],device_arrai:[2,3],device_array_0:2,device_array_1:2,device_array_2:2,devicelik:3,diag:1,diagnos:3,diagon:[1,3],dictionari:[2,3],differ:[1,2,3],differenti:[0,2,4],difficult:3,dim:[1,2,3],dim_i:[3,4],dim_x:[3,4],dim_z:[3,4],dimens:[1,3],dimension:0,dir:1,direct:[1,3,4],directli:[3,4],discard:1,discret:3,disk:[1,3],dist:3,distanc:[1,3,4],distribut:1,div:1,diverg:1,divis:[1,3],dlpack:3,doe:[1,3,4],doesn:3,domain:3,done:2,dot:[1,2,3],doubl:[1,3],down:3,download:2,driver:3,dt:4,dtype:[2,3],dual:1,dure:[1,3],dynam:[2,3,4],e:[1,2,3,4],each:[1,3,4],easi:[2,3],easili:3,edg:[1,3,4],edge0:1,edge1:1,edge_callback:4,edge_count:4,edge_indic:4,edge_k:4,edge_kd:4,edge_rest_angl:4,effect:3,effici:[3,4],eig3:1,eigen:1,either:[2,3],elast:4,element:[1,3,4],empti:[2,3],empty_lik:3,en:4,enabl:3,enclos:3,encod:[],encount:3,end:3,energi:4,enough:[3,4],ensur:[2,3],entir:3,entri:4,environ:3,epsilon:1,equal:[1,3,4],equat:4,equival:[1,3],error:[1,3],establish:3,et:4,etc:[2,3,4],euler:4,eval:2,evalu:[1,2,3],even:[1,3],everi:[3,4],exact:4,exampl:[0,3,4],example_funct:3,except:[2,3],execut:[2,3],exist:[1,2,3],exit:3,exp:1,expect:[3,4],expect_eq:1,expect_near:1,expect_neq:1,explicit:[3,4],explicitli:[2,3],exponenti:[1,3],expos:[2,3,4],express:[2,3],extens:[2,3],extent:4,extern:3,extract:1,f0:4,f:[1,3],face:[1,3,4],face_callback:4,factor:1,fail:3,fall:3,fals:[1,2,3,4],familiar:3,fast:2,faster:1,featur:[0,1,3],fem:4,field:[1,3],file:3,find:[1,3],fine:3,finit:[],first:[1,2,3,4],fix:[1,3,4],fix_bottom:4,fix_left:4,fix_right:4,fix_top:4,flatten:[1,3,4],flip:4,float16:1,float32:[1,2,3],float64:[1,3],floor:[1,3],floordiv:1,flow:3,fluid:3,fold:3,folder:3,follow:[2,3,4],foo:3,footnot:1,forc:[3,4],form:[1,3,4],format:[1,3],forward:[3,4],found:1,four:4,fourth:4,foward:3,fraction:1,frame:4,framework:[1,2,3],free:[1,3],freeli:3,friction:4,from:[1,2,3,4],from_numpi:2,from_torch:3,front:1,full:[3,4],func:[1,3],fundament:3,futur:[3,4],g:[1,2,3,4],gen:3,gener:[1,2,3,4],geometr:3,geometri:[0,2,3,4],get:[2,3],get_devic:3,give:3,given:[1,3,4],global:[1,2,3],good:2,got:3,gpu:[2,3],grad:3,gradient:[1,3,4],grain:3,graph:[0,4],graphic:[2,3],greater:[1,3],grid:[0,1,4],ground:4,group:4,h:4,ha:[3,4],half:4,half_width:4,halfwai:1,handi:3,handl:3,hard:3,hash:[0,1],hash_grid_point_id:1,hash_grid_queri:[1,3],hash_grid_query_next:[1,3],hash_grid_query_t:1,hashgrid:3,have:[2,3],height:4,help:3,helper:[3,4],hemispher:1,hermit:1,hexahedr:4,hide:3,hierarchi:3,high:2,hint:3,hit:[1,3],hold:4,homogen:1,hood:3,host:[2,3],host_arrai:[2,3],host_array_0:2,host_array_1:2,host_array_2:2,houdini:3,how:3,howev:[2,4],http:4,hx:4,hy:4,hydrodynam:3,hz:4,i:[1,3,4],i_:1,i_m:4,id:[1,3],ident:1,identifi:[1,3],imaginari:1,immut:0,implement:[1,2,3,4],implicit:[3,4],implicit_euler_method:4,impos:3,includ:[2,4],inclus:3,incom:3,incompat:3,incred:3,independ:[3,4],index:[0,1,2,3,4],indic:[1,3,4],individu:3,inerti:1,inertia:[1,3,4],infer:[2,3],inform:3,init:[2,3],initi:[0,1,2,4],input:[1,2,3,4],input_buff:3,input_dim:3,insert:3,insid:[1,3],inspect:3,instal:0,instead:[2,3],instruct:2,int16:[1,3],int32:[1,3],int64:[1,3],int8:[1,3],integ:[1,3],integr:[0,3],intend:4,interact:3,interfac:3,interior:4,intermedi:3,intern:4,interop:0,interoper:3,interpol:[1,3],interpret:3,intersect:1,intersect_tri_tri:1,intrins:1,introduc:3,introduct:0,intuit:1,invalid:2,invers:[1,4],invok:3,involv:3,issu:3,item:1,iter:[1,3,4],its:[1,4],itself:3,ix:1,iy:1,iz:1,j:[1,3,4],j_out:1,j_start:1,jacobian:0,jax:0,jit:2,joint:4,joint_armatur:4,joint_axi:4,joint_count:[1,4],joint_limit_k:4,joint_limit_kd:4,joint_limit_low:4,joint_limit_upp:4,joint_par:[1,4],joint_prismat:4,joint_qd_start:1,joint_revolut:4,joint_start:1,joint_target:4,joint_target_k:4,joint_target_kd:4,joint_typ:4,joint_x_cm:4,joint_x_pj:4,joint_xform:4,joint_xform_child:4,k:[1,3,4],k_:4,k_damp:4,k_lambda:4,k_mu:4,kd:4,ke:4,keep:3,kernel:[0,2],kf:4,kinemat:4,kwarg:3,l:[1,3,4],laid:1,lambda:[2,4],lame:4,languag:0,larg:3,largest:1,latter:3,launch:[0,1,2],launch_kernels_to_be_differenti:3,layer:1,layout:1,lead:3,left:[1,4],length:[1,3,4],length_sq:1,lerp:1,less:[1,3],level:[2,4],li:4,librari:[1,2,3],lie:3,like:[1,3],limit:[3,4],line:3,linear:[1,2,3],linearli:1,list:[2,3,4],littl:3,live:[2,3],lm:4,lmax:4,load:[2,3],load_from_nvdb:3,local:[1,3,4],locat:[1,3,4],log10:1,log2:1,log:1,lookup:3,loop:[3,4],loss:3,low:3,lower:[1,3,4],lower_bound:1,lt:4,m00:[],m01:[],m02:[],m03:[],m10:[],m11:[],m12:[],m13:[],m20:[],m21:[],m22:[],m23:[],m30:[],m31:[],m32:[],m33:[],m:[1,3,4],m_start:1,made:3,magnitud:1,mai:[1,2,3,4],main:2,maintain:[3,4],major:1,make:[2,3,4],manag:[2,3],mani:[3,4],manifold:4,manual:2,map:3,map_cuda_devic:3,marix:1,mark:3,mass:4,mat22:[1,2,3],mat22d:1,mat22f:1,mat22h:1,mat33:[1,2,3],mat33d:1,mat33f:1,mat33h:1,mat44:[1,2,3],mat44d:1,mat44f:1,mat44h:1,mat:1,match:3,materi:4,math:[0,2,3],mathbb:3,mathbf:3,matric:[1,3],matrix33:2,matrix:[1,3],matrix_t:[],max:[1,3],max_dist:1,max_t:1,maxim:4,maximum:[1,3],md:2,mean:[3,4],mechan:3,memori:[0,1,3,4],mesh:[0,1,4],mesh_eval_face_norm:1,mesh_eval_posit:1,mesh_eval_veloc:1,mesh_get:1,mesh_get_index:1,mesh_get_point:1,mesh_get_veloc:1,mesh_query_aabb:1,mesh_query_aabb_next:1,mesh_query_aabb_t:1,mesh_query_point:1,mesh_query_rai:[1,3],method:[1,3,4],min:[1,3],minim:3,minimum:1,mlp:1,mod:1,mode:3,model:0,modelbuild:4,modifi:3,modul:[0,2,3,4],modulu:3,moller:1,more:[1,3],most:[1,3,4],move:[1,3],mu:4,mul:1,multi:[0,1],multipl:[2,3],multipli:1,muscl:4,must:[1,2,3],mutat:[2,3],mygrid:3,n:[1,2,3],name:3,nanovdb:3,narrow:3,nativ:3,natur:1,ndarrai:3,ndim:3,nearest:[1,3],need:[2,3],neg:1,neighbor:[1,3],neohookean:4,nest:3,network:1,next:1,node:4,nois:1,non:[1,3,4],none:[1,3,4],nonzero:1,normal:[1,3],notabl:1,notat:2,note:[1,2,3],np:[2,3],num_env:3,numba:0,number:[1,2,3,4],numer:3,numpi:[0,1,2],nvdb:3,object:[1,3,4],obtain:4,occur:[1,3],offer:3,offset:1,often:[2,3],omit:3,onc:[3,4],one:[2,3,4],ones:2,onli:[1,3,4],onto:[1,2,3],open:3,openvdb:3,oper:[0,2],oppos:4,option:[1,3,4],order:[1,3],ordin:3,org:4,orient:4,origin:[3,4],orthogon:1,other:[0,3],otherwis:[1,3],ouput_dim:3,out:[1,3],outer:1,output:[1,2,3,4],output_buff:3,output_dim:3,output_index:3,outsid:3,outstand:3,over:[1,3],overhead:3,overlap:[1,3],overrid:4,overwrit:3,own:[3,4],owner:3,p1:1,p2:1,p:[1,3],packag:2,page:0,pair:4,parallel:[1,3],param:[],paramet:[1,2,3,4],paramt:4,parent:4,part:[1,3],particip:3,particl:[3,4],particle_count:4,particle_inv_mass:4,particle_mass:4,particle_q:4,particle_qd:4,particularli:3,pass:[1,3],path:3,pattern:2,pd:4,pelas:4,pen:4,per:[1,3,4],perceptron:1,perform:[2,3,4],period:1,perlin:1,physic:[2,4],pin:3,pipelin:3,pitch:1,place:4,planar:4,plane:[1,4],pleas:[2,3],pnois:1,po:[1,4],point:[1,3,4],pointer:3,points_in_world_spac:3,poorli:3,popular:3,pose:4,posit:[1,3,4],possibl:[2,3,4],pow:1,power:1,pre:2,precis:3,precomput:3,preserv:[1,4],previou:3,previous:3,primari:3,print:[0,1],print_launch:3,printf:[1,3],problem:3,problemat:3,procedur:2,process:[1,2,3],product:[1,2,3],program:[1,2,3],progress:4,propag:[3,4],protocol:3,provid:3,pt:1,ptr:3,ptx:2,put:3,px:1,py:1,python:[2,3,4],pytorch:[0,1,2],pz:1,q0:1,q1:1,q2:1,q:[1,2,3],q_grad_i:3,qr3:1,qr:1,quantiti:[],quarternion:1,quat:[1,2,3],quat_from_axis_angl:1,quat_from_matrix:1,quat_ident:1,quat_invers:1,quat_rot:1,quat_rotate_inv:1,quat_rpi:1,quat_slerp:1,quat_to_axis_angl:1,quat_to_matrix:1,quatd:1,quaternion:[0,2,3],quatf:1,quath:1,queri:[1,3],queu:2,r:[1,2,3,4],radian:[1,4],radiu:[1,3,4],rai:[1,3],rais:[1,3],rand:3,rand_init:1,randf:1,randi:1,randn:1,random:[0,3],rang:[1,3,4],rapidli:4,rather:[2,4],ray_dir:3,ray_hit:3,ray_origin:3,raycast:3,rb:3,re:[1,3],read:[2,3],readi:4,readm:2,real:[1,3],reason:3,rebuild:3,recommend:[3,4],record:3,rectangular:4,recurs:2,redund:3,refer:[0,2],refit:3,regard:3,regist:[2,3],regular:4,rel:4,relax:4,repeat:3,replai:3,repres:[1,3,4],represent:4,request:3,requir:[3,4],requires_grad:[3,4],reshap:3,resid:3,resourc:3,respect:[3,4],respons:3,rest:4,restart:2,restor:3,restrict:3,result:[1,2,3],retriev:[1,3],retrun:1,returend:1,reus:3,revers:3,reverse_wind:4,right:[1,4],rigid:[1,3,4],ring:1,rint:1,rng:1,robust:1,roll:1,root:4,rot:[1,4],rotat:[1,4],rotate_rodriguez:[],round:[1,3],row:[1,3],run:3,runtim:[0,2,4],s0:1,s10:1,s11:1,s12:1,s13:1,s14:1,s15:1,s16:1,s17:1,s18:1,s19:1,s1:1,s20:1,s21:1,s22:1,s23:1,s24:1,s25:1,s26:1,s27:1,s28:1,s29:1,s2:1,s30:1,s31:1,s32:1,s33:1,s34:1,s35:1,s3:1,s4:1,s5:1,s6:1,s7:1,s8:1,s9:1,s:[1,3,4],safe:3,same:[1,2,3],sampl:[1,3],sample_cdf:1,sample_grid:3,sample_triangl:1,sample_unit_cub:1,sample_unit_disk:1,sample_unit_hemispher:1,sample_unit_hemisphere_surfac:1,sample_unit_r:1,sample_unit_spher:1,sample_unit_sphere_surfac:1,sample_unit_squar:1,sampling_mod:1,scalar:0,scale:[1,3,4],scene:4,scope:0,scopeddevic:3,screw:1,script:3,sdf:3,search:[0,1],second:[1,3,4],secondari:3,section:4,see:[2,3,4],seed:1,select:[1,3],select_index:3,semant:2,semi:4,semiimplicitintegr:4,sens:[1,3],separ:3,sequenc:2,sequenti:3,seri:3,serial:3,set:[1,2,3,4],set_devic:3,shade:2,shape:[2,3,4],shape_bodi:4,shape_count:4,shape_geo_scal:4,shape_geo_src:4,shape_geo_typ:4,shape_materi:4,shape_t:[],shape_transform:4,share:[1,2,3],sheet:4,should:[1,2,3,4],show:3,shown:3,side:3,sigma:1,sign:[1,3],signatur:[2,3],signific:3,silent:3,sim:4,similar:[1,2,3],simpl:3,simple_kernel:[2,3],simpli:3,simplifi:3,simul:[0,2,3],sin:1,sinc:[3,4],sine:1,singl:[1,3,4],singular:1,sinh:1,size:3,skew:1,slice:[2,3],slower:1,small:4,smallest:[1,3],smallmatrix:3,smith:4,smooth:3,smoothli:1,smoothstep:1,snippet:3,so:[2,3,4],softwar:3,solid:4,some:[1,2,3],sort:1,sourc:[2,3,4],space:[1,3,4],spars:3,spatial:[0,3],spatial_adjoint:1,spatial_bottom:[1,3],spatial_cross:1,spatial_cross_du:1,spatial_dot:1,spatial_jacobian:1,spatial_mass:1,spatial_matrix:[1,3],spatial_matrix_t:1,spatial_matrixd:1,spatial_matrixf:1,spatial_matrixh:1,spatial_top:[1,3],spatial_vector:[1,3],spatial_vector_t:1,spatial_vectord:1,spatial_vectorf:1,spatial_vectorh:1,specfi:4,special:3,specif:3,specifi:[1,2,3,4],sph:3,sphere:[1,3,4],spring:4,spring_control:4,spring_count:4,spring_damp:4,spring_indic:4,spring_rest_length:4,spring_stiff:4,sqrt:1,squar:[1,3],src:[2,3],src_arrai:3,stabl:4,standard:[3,4],start:[1,3],startup:2,state:[0,1,2,3],state_in:4,state_out:4,stdout:1,step:[0,1,4],stiff:4,still:3,storag:3,store:[1,2,3,4],str:3,stream:3,strict:3,strictli:3,stride:3,string:[1,3],strong:0,strongli:[2,4],structur:[2,3,4],studio:3,style:[1,3],sub:1,subject:4,subsequ:3,subtract:[1,3],success:3,suit:3,sum:3,support:[2,3,4],surfac:[1,4],surpris:3,suspect:3,svd3:1,svd:1,symbol:3,symmetr:1,symplect:4,synchron:[0,2],synchronize_devic:3,syntax:[1,2,3],system:[3,4],t:[1,3,4],take:[1,3],tan:1,tangent:1,tanh:1,tape:3,target:[3,4],templat:3,temporari:[2,3],tendon:4,tensor:[3,4],test:[1,3],tet_activ:4,tet_count:4,tet_indic:4,tet_materi:4,tet_pos:4,tetrahdera:4,tetrahedr:4,tetrahedra:4,tetrahedron:4,tetrhedra:4,than:[1,2,3,4],thei:[3,4],them:3,themselv:3,therefor:3,thi:[1,2,3,4],thing:3,third:4,those:3,thread:[1,2,3],three:[1,4],through:0,tid:[1,2,3],tile:3,tile_point:3,time:[2,3,4],to_torch:3,togeth:[1,2],toler:1,tool:3,top:[1,3,4],topolog:3,torch:3,total:4,tr:1,trace:1,track:[1,3],tranform:1,transfer:[2,3,4],transform:[0,3,4],transform_class:[],transform_get_rot:1,transform_get_transl:1,transform_ident:1,transform_invers:1,transform_multipli:1,transform_point:1,transform_t:1,transform_vector:1,transformd:1,transformf:1,transformh:1,translat:[1,3],transpos:1,travers:1,treat:[1,3,4],tri_activ:4,tri_count:4,tri_drag:4,tri_indic:4,tri_k:4,tri_ka:4,tri_kb:4,tri_kd:4,tri_lift:4,tri_pos:4,triangl:[1,3,4],trianglular:4,triangular:1,trigger:2,trilinear:3,trunc:1,tupl:[1,2,3,4],twice:3,twist:[1,3],two:[1,2,3,4],type:[0,4],type_capsul:3,type_cub:3,type_spher:3,typic:[1,3],u0:1,u1:1,u2:1,u:[1,3],uint16:[1,3],uint32:[1,3],uint64:[1,3],uint8:[1,3],unalloc:3,uncompress:3,uncondition:4,uncorrel:1,under:[3,4],underli:[2,3],understand:3,uniformli:1,uniniti:3,uninitiz:2,union:3,uniqu:3,unit:[1,3,4],unlik:2,unot:1,unpredict:3,unrol:3,unsign:3,unsupport:0,up:3,updat:[1,3,4],upper:[1,3,4],us:[1,2,3,4],usag:[0,1,3],usd:1,user:[0,1,2,4],util:0,uvw:1,v0:1,v1:1,v2:1,v:[1,2,3],valid:[2,3],valu:[0,1,2,4],vari:4,variabl:[1,2,3],variat:4,variou:3,vdb:3,vec2:[1,2,3],vec2d:1,vec2f:1,vec2h:1,vec2ub:1,vec3:[1,2,3,4],vec3d:1,vec3f:1,vec3h:1,vec3ub:1,vec4:[1,2,3],vec4d:1,vec4f:1,vec4h:1,vec4ub:1,vec:1,vector:[0,2],vector_t:[],vel:4,veloc:[1,3,4],velocit:1,veri:3,verif:0,verifi:3,verify_cuda:3,version:3,vertex:[1,3,4],vertic:4,via:[2,3],view:[2,3],violat:3,viscoelast:4,visibl:2,visual:3,volum:[0,4],volume_index_to_world:1,volume_index_to_world_dir:1,volume_lookup_f:1,volume_lookup_i:1,volume_lookup_v:1,volume_sample_f:[1,3],volume_sample_i:1,volume_sample_v:1,volume_store_f:1,volume_store_i:1,volume_store_v:1,volume_world_to_index:[1,3],volume_world_to_index_dir:1,volumetr:[3,4],voxel:[1,3],voxel_s:3,w:[1,3,4],wa:3,wai:[1,3],wait:3,want:3,warp:[1,2,3,4],watertight:1,waypoint:4,we:[2,3],weight:1,well:[1,3],what:3,when:[1,3,4],where:[1,2,3],whether:3,which:[1,2,3,4],whole:1,width:[3,4],wiki:4,wikipedia:4,wind:4,wise:1,wish:3,within:3,withing:1,word:1,work:[3,4],workflow:3,world:[1,3,4],would:3,wp:[1,2,3,4],wrap:2,wrapper:3,wrench:1,write:[2,3],written:3,x:[1,2,3,4],xform:4,xpbd:4,xpbdintegr:4,xy:1,xyz:1,xyzt:1,y:[1,2,3,4],yaw:1,you:3,your:4,z:[1,3,4],zero:[1,2,3,4],zeros_lik:3,zip:3},titles:["NVIDIA Warp Documentation","Kernel Reference","Introduction","Runtime Reference","Simulation Reference"],titleterms:{"boolean":3,"default":3,"function":3,advanc:3,arithmet:3,arrai:3,bound:3,built:2,check:3,comparison:3,compil:2,constant:3,content:0,context:3,convers:3,cuda:3,cupi:3,current:3,custom:3,data:3,debug:3,detail:2,devic:3,differenti:3,dimension:3,document:0,exampl:2,featur:2,geometri:1,graph:3,grid:3,hash:3,immut:2,indic:0,initi:3,instal:2,integr:4,interop:3,introduct:2,jacobian:3,jax:3,kernel:[1,3],languag:2,launch:3,math:1,memori:2,mesh:3,model:[2,4],multi:3,numba:3,numpi:3,nvidia:0,oper:[1,3],other:1,print:3,pytorch:3,quaternion:1,random:1,refer:[1,3,4],runtim:3,scalar:[1,3],scope:3,simul:4,spatial:1,state:4,step:3,strong:2,synchron:3,tabl:0,through:3,todo:4,transform:1,type:[1,2,3],unsupport:2,usag:2,user:3,util:1,valu:3,vector:[1,3],verif:3,volum:[1,3],warp:0}}) \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py index 306592730..b809bf067 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -21,7 +21,7 @@ copyright = '2022, NVIDIA' author = 'NVIDIA' -version = '0.7.1' +version = '0.7.2' # -- General configuration --------------------------------------------------- diff --git a/docs/modules/functions.rst b/docs/modules/functions.rst index 42d8e999c..d80aed0f0 100644 --- a/docs/modules/functions.rst +++ b/docs/modules/functions.rst @@ -68,12 +68,12 @@ Vector Types Scalar Math --------------- -.. function:: min(x: int32, y: int32) -> int32 +.. function:: min(x: uint32, y: uint32) -> uint32 Return the minimum of two scalars. -.. function:: min(x: int8, y: int8) -> int8 +.. function:: min(x: int16, y: int16) -> int16 Return the minimum of two scalars. @@ -83,42 +83,42 @@ Scalar Math Return the minimum of two scalars. -.. function:: min(x: int16, y: int16) -> int16 +.. function:: min(x: int8, y: int8) -> int8 Return the minimum of two scalars. -.. function:: min(x: uint32, y: uint32) -> uint32 +.. function:: min(x: float16, y: float16) -> float16 Return the minimum of two scalars. -.. function:: min(x: float16, y: float16) -> float16 +.. function:: min(x: uint16, y: uint16) -> uint16 Return the minimum of two scalars. -.. function:: min(x: uint64, y: uint64) -> uint64 +.. function:: min(x: int32, y: int32) -> int32 Return the minimum of two scalars. -.. function:: min(x: uint16, y: uint16) -> uint16 +.. function:: min(x: uint64, y: uint64) -> uint64 Return the minimum of two scalars. -.. function:: min(x: int64, y: int64) -> int64 +.. function:: min(x: float32, y: float32) -> float32 Return the minimum of two scalars. -.. function:: min(x: uint8, y: uint8) -> uint8 +.. function:: min(x: int64, y: int64) -> int64 Return the minimum of two scalars. -.. function:: min(x: float32, y: float32) -> float32 +.. function:: min(x: uint8, y: uint8) -> uint8 Return the minimum of two scalars. @@ -128,122 +128,122 @@ Scalar Math Return the minimum of two scalars. -.. function:: min(x: vec2h, y: vec2h) -> vec2h +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3h, y: vec3h) -> vec3h +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4h, y: vec4h) -> vec4h +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2d, y: vec2d) -> vec2d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3d, y: vec3d) -> vec3d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4d, y: vec4d) -> vec4d +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2f, y: vec2f) -> vec2f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2f, y: vec2) -> vec2f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2, y: vec2f) -> vec2f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec2, y: vec2) -> vec2f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3f, y: vec3f) -> vec3f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3f, y: vec3) -> vec3f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3, y: vec3f) -> vec3f +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec3, y: vec3) -> vec3f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4f, y: vec4f) -> vec4f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4f, y: vec4) -> vec4f +.. function:: min(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4, y: vec4f) -> vec4f +.. function:: min(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise minimum of two vectors. -.. function:: min(x: vec4, y: vec4) -> vec4f +.. function:: min(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise minimum of two vectors. -.. function:: min(x: vector_t, y: vector_t) -> vector_t +.. function:: min(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Return the element wise minimum of two vectors. -.. function:: max(x: int32, y: int32) -> int32 +.. function:: max(x: uint32, y: uint32) -> uint32 Return the maximum of two scalars. -.. function:: max(x: int8, y: int8) -> int8 +.. function:: max(x: int16, y: int16) -> int16 Return the maximum of two scalars. @@ -253,42 +253,42 @@ Scalar Math Return the maximum of two scalars. -.. function:: max(x: int16, y: int16) -> int16 +.. function:: max(x: int8, y: int8) -> int8 Return the maximum of two scalars. -.. function:: max(x: uint32, y: uint32) -> uint32 +.. function:: max(x: float16, y: float16) -> float16 Return the maximum of two scalars. -.. function:: max(x: float16, y: float16) -> float16 +.. function:: max(x: uint16, y: uint16) -> uint16 Return the maximum of two scalars. -.. function:: max(x: uint64, y: uint64) -> uint64 +.. function:: max(x: int32, y: int32) -> int32 Return the maximum of two scalars. -.. function:: max(x: uint16, y: uint16) -> uint16 +.. function:: max(x: uint64, y: uint64) -> uint64 Return the maximum of two scalars. -.. function:: max(x: int64, y: int64) -> int64 +.. function:: max(x: float32, y: float32) -> float32 Return the maximum of two scalars. -.. function:: max(x: uint8, y: uint8) -> uint8 +.. function:: max(x: int64, y: int64) -> int64 Return the maximum of two scalars. -.. function:: max(x: float32, y: float32) -> float32 +.. function:: max(x: uint8, y: uint8) -> uint8 Return the maximum of two scalars. @@ -298,122 +298,122 @@ Scalar Math Return the maximum of two scalars. -.. function:: max(x: vec2h, y: vec2h) -> vec2h +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3h, y: vec3h) -> vec3h +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4h, y: vec4h) -> vec4h +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2d, y: vec2d) -> vec2d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3d, y: vec3d) -> vec3d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4d, y: vec4d) -> vec4d +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2f, y: vec2f) -> vec2f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2f, y: vec2) -> vec2f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2, y: vec2f) -> vec2f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec2, y: vec2) -> vec2f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3f, y: vec3f) -> vec3f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3f, y: vec3) -> vec3f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3, y: vec3f) -> vec3f +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec3, y: vec3) -> vec3f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4f, y: vec4f) -> vec4f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4f, y: vec4) -> vec4f +.. function:: max(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4, y: vec4f) -> vec4f +.. function:: max(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Return the element wise maximum of two vectors. -.. function:: max(x: vec4, y: vec4) -> vec4f +.. function:: max(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Return the element wise maximum of two vectors. -.. function:: max(x: vector_t, y: vector_t) -> vector_t +.. function:: max(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Return the element wise maximum of two vectors. -.. function:: clamp(x: int32, a: int32, b: int32) -> int32 +.. function:: clamp(x: uint32, a: uint32, b: uint32) -> uint32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int8, a: int8, b: int8) -> int8 +.. function:: clamp(x: int16, a: int16, b: int16) -> int16 Clamp the value of x to the range [a, b]. @@ -423,42 +423,42 @@ Scalar Math Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int16, a: int16, b: int16) -> int16 +.. function:: clamp(x: int8, a: int8, b: int8) -> int8 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint32, a: uint32, b: uint32) -> uint32 +.. function:: clamp(x: float16, a: float16, b: float16) -> float16 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: float16, a: float16, b: float16) -> float16 +.. function:: clamp(x: uint16, a: uint16, b: uint16) -> uint16 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint64, a: uint64, b: uint64) -> uint64 +.. function:: clamp(x: int32, a: int32, b: int32) -> int32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint16, a: uint16, b: uint16) -> uint16 +.. function:: clamp(x: uint64, a: uint64, b: uint64) -> uint64 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: int64, a: int64, b: int64) -> int64 +.. function:: clamp(x: float32, a: float32, b: float32) -> float32 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: uint8, a: uint8, b: uint8) -> uint8 +.. function:: clamp(x: int64, a: int64, b: int64) -> int64 Clamp the value of x to the range [a, b]. -.. function:: clamp(x: float32, a: float32, b: float32) -> float32 +.. function:: clamp(x: uint8, a: uint8, b: uint8) -> uint8 Clamp the value of x to the range [a, b]. @@ -468,12 +468,12 @@ Scalar Math Clamp the value of x to the range [a, b]. -.. function:: abs(x: int32) -> int32 +.. function:: abs(x: uint32) -> uint32 Return the absolute value of x. -.. function:: abs(x: int8) -> int8 +.. function:: abs(x: int16) -> int16 Return the absolute value of x. @@ -483,42 +483,42 @@ Scalar Math Return the absolute value of x. -.. function:: abs(x: int16) -> int16 +.. function:: abs(x: int8) -> int8 Return the absolute value of x. -.. function:: abs(x: uint32) -> uint32 +.. function:: abs(x: float16) -> float16 Return the absolute value of x. -.. function:: abs(x: float16) -> float16 +.. function:: abs(x: uint16) -> uint16 Return the absolute value of x. -.. function:: abs(x: uint64) -> uint64 +.. function:: abs(x: int32) -> int32 Return the absolute value of x. -.. function:: abs(x: uint16) -> uint16 +.. function:: abs(x: uint64) -> uint64 Return the absolute value of x. -.. function:: abs(x: int64) -> int64 +.. function:: abs(x: float32) -> float32 Return the absolute value of x. -.. function:: abs(x: uint8) -> uint8 +.. function:: abs(x: int64) -> int64 Return the absolute value of x. -.. function:: abs(x: float32) -> float32 +.. function:: abs(x: uint8) -> uint8 Return the absolute value of x. @@ -528,12 +528,12 @@ Scalar Math Return the absolute value of x. -.. function:: sign(x: int32) -> int32 +.. function:: sign(x: uint32) -> uint32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int8) -> int8 +.. function:: sign(x: int16) -> int16 Return -1 if x < 0, return 1 otherwise. @@ -543,42 +543,42 @@ Scalar Math Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int16) -> int16 +.. function:: sign(x: int8) -> int8 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint32) -> uint32 +.. function:: sign(x: float16) -> float16 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: float16) -> float16 +.. function:: sign(x: uint16) -> uint16 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint64) -> uint64 +.. function:: sign(x: int32) -> int32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint16) -> uint16 +.. function:: sign(x: uint64) -> uint64 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: int64) -> int64 +.. function:: sign(x: float32) -> float32 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: uint8) -> uint8 +.. function:: sign(x: int64) -> int64 Return -1 if x < 0, return 1 otherwise. -.. function:: sign(x: float32) -> float32 +.. function:: sign(x: uint8) -> uint8 Return -1 if x < 0, return 1 otherwise. @@ -588,12 +588,12 @@ Scalar Math Return -1 if x < 0, return 1 otherwise. -.. function:: step(x: int32) -> int32 +.. function:: step(x: uint32) -> uint32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int8) -> int8 +.. function:: step(x: int16) -> int16 Return 1.0 if x < 0.0, return 0.0 otherwise. @@ -603,42 +603,42 @@ Scalar Math Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int16) -> int16 +.. function:: step(x: int8) -> int8 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint32) -> uint32 +.. function:: step(x: float16) -> float16 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: float16) -> float16 +.. function:: step(x: uint16) -> uint16 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint64) -> uint64 +.. function:: step(x: int32) -> int32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint16) -> uint16 +.. function:: step(x: uint64) -> uint64 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: int64) -> int64 +.. function:: step(x: float32) -> float32 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: uint8) -> uint8 +.. function:: step(x: int64) -> int64 Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: step(x: float32) -> float32 +.. function:: step(x: uint8) -> uint8 Return 1.0 if x < 0.0, return 0.0 otherwise. @@ -648,12 +648,12 @@ Scalar Math Return 1.0 if x < 0.0, return 0.0 otherwise. -.. function:: nonzero(x: int32) -> int32 +.. function:: nonzero(x: uint32) -> uint32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int8) -> int8 +.. function:: nonzero(x: int16) -> int16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. @@ -663,42 +663,42 @@ Scalar Math Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int16) -> int16 +.. function:: nonzero(x: int8) -> int8 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint32) -> uint32 +.. function:: nonzero(x: float16) -> float16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: float16) -> float16 +.. function:: nonzero(x: uint16) -> uint16 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint64) -> uint64 +.. function:: nonzero(x: int32) -> int32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint16) -> uint16 +.. function:: nonzero(x: uint64) -> uint64 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: int64) -> int64 +.. function:: nonzero(x: float32) -> float32 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: uint8) -> uint8 +.. function:: nonzero(x: int64) -> int64 Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: nonzero(x: float32) -> float32 +.. function:: nonzero(x: uint8) -> uint8 Return 1.0 if x is not equal to zero, return 0.0 otherwise. @@ -708,17 +708,17 @@ Scalar Math Return 1.0 if x is not equal to zero, return 0.0 otherwise. -.. function:: sin(x: float16) -> float16 +.. function:: sin(x: float64) -> float64 Return the sine of x in radians. -.. function:: sin(x: float64) -> float64 +.. function:: sin(x: float32) -> float32 Return the sine of x in radians. -.. function:: sin(x: float32) -> float32 +.. function:: sin(x: float16) -> float16 Return the sine of x in radians. @@ -728,17 +728,17 @@ Scalar Math Return the sine of x in radians. -.. function:: cos(x: float16) -> float16 +.. function:: cos(x: float64) -> float64 Return the cosine of x in radians. -.. function:: cos(x: float64) -> float64 +.. function:: cos(x: float32) -> float32 Return the cosine of x in radians. -.. function:: cos(x: float32) -> float32 +.. function:: cos(x: float16) -> float16 Return the cosine of x in radians. @@ -748,17 +748,17 @@ Scalar Math Return the cosine of x in radians. -.. function:: acos(x: float16) -> float16 +.. function:: acos(x: float64) -> float64 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: acos(x: float64) -> float64 +.. function:: acos(x: float32) -> float32 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: acos(x: float32) -> float32 +.. function:: acos(x: float16) -> float16 Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. @@ -768,17 +768,17 @@ Scalar Math Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float16) -> float16 +.. function:: asin(x: float64) -> float64 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float64) -> float64 +.. function:: asin(x: float32) -> float32 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: asin(x: float32) -> float32 +.. function:: asin(x: float16) -> float16 Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. @@ -788,17 +788,17 @@ Scalar Math Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. -.. function:: sqrt(x: float16) -> float16 +.. function:: sqrt(x: float64) -> float64 Return the sqrt of x, where x is positive. -.. function:: sqrt(x: float64) -> float64 +.. function:: sqrt(x: float32) -> float32 Return the sqrt of x, where x is positive. -.. function:: sqrt(x: float32) -> float32 +.. function:: sqrt(x: float16) -> float16 Return the sqrt of x, where x is positive. @@ -808,17 +808,17 @@ Scalar Math Return the sqrt of x, where x is positive. -.. function:: tan(x: float16) -> float16 +.. function:: tan(x: float64) -> float64 Return tangent of x in radians. -.. function:: tan(x: float64) -> float64 +.. function:: tan(x: float32) -> float32 Return tangent of x in radians. -.. function:: tan(x: float32) -> float32 +.. function:: tan(x: float16) -> float16 Return tangent of x in radians. @@ -828,17 +828,17 @@ Scalar Math Return tangent of x in radians. -.. function:: atan(x: float16) -> float16 +.. function:: atan(x: float64) -> float64 Return arctan of x. -.. function:: atan(x: float64) -> float64 +.. function:: atan(x: float32) -> float32 Return arctan of x. -.. function:: atan(x: float32) -> float32 +.. function:: atan(x: float16) -> float16 Return arctan of x. @@ -848,17 +848,17 @@ Scalar Math Return arctan of x. -.. function:: atan2(y: float16, x: float16) -> float16 +.. function:: atan2(y: float64, x: float64) -> float64 Return atan2 of x. -.. function:: atan2(y: float64, x: float64) -> float64 +.. function:: atan2(y: float32, x: float32) -> float32 Return atan2 of x. -.. function:: atan2(y: float32, x: float32) -> float32 +.. function:: atan2(y: float16, x: float16) -> float16 Return atan2 of x. @@ -868,17 +868,17 @@ Scalar Math Return atan2 of x. -.. function:: sinh(x: float16) -> float16 +.. function:: sinh(x: float64) -> float64 Return the sinh of x. -.. function:: sinh(x: float64) -> float64 +.. function:: sinh(x: float32) -> float32 Return the sinh of x. -.. function:: sinh(x: float32) -> float32 +.. function:: sinh(x: float16) -> float16 Return the sinh of x. @@ -888,17 +888,17 @@ Scalar Math Return the sinh of x. -.. function:: cosh(x: float16) -> float16 +.. function:: cosh(x: float64) -> float64 Return the cosh of x. -.. function:: cosh(x: float64) -> float64 +.. function:: cosh(x: float32) -> float32 Return the cosh of x. -.. function:: cosh(x: float32) -> float32 +.. function:: cosh(x: float16) -> float16 Return the cosh of x. @@ -908,17 +908,17 @@ Scalar Math Return the cosh of x. -.. function:: tanh(x: float16) -> float16 +.. function:: tanh(x: float64) -> float64 Return the tanh of x. -.. function:: tanh(x: float64) -> float64 +.. function:: tanh(x: float32) -> float32 Return the tanh of x. -.. function:: tanh(x: float32) -> float32 +.. function:: tanh(x: float16) -> float16 Return the tanh of x. @@ -938,17 +938,17 @@ Scalar Math Convert degrees into radians. -.. function:: log(x: float16) -> float16 +.. function:: log(x: float64) -> float64 Return the natural log (base-e) of x, where x is positive. -.. function:: log(x: float64) -> float64 +.. function:: log(x: float32) -> float32 Return the natural log (base-e) of x, where x is positive. -.. function:: log(x: float32) -> float32 +.. function:: log(x: float16) -> float16 Return the natural log (base-e) of x, where x is positive. @@ -958,17 +958,17 @@ Scalar Math Return the natural log (base-e) of x, where x is positive. -.. function:: log2(x: float16) -> float16 +.. function:: log2(x: float64) -> float64 Return the natural log (base-2) of x, where x is positive. -.. function:: log2(x: float64) -> float64 +.. function:: log2(x: float32) -> float32 Return the natural log (base-2) of x, where x is positive. -.. function:: log2(x: float32) -> float32 +.. function:: log2(x: float16) -> float16 Return the natural log (base-2) of x, where x is positive. @@ -978,17 +978,17 @@ Scalar Math Return the natural log (base-2) of x, where x is positive. -.. function:: log10(x: float16) -> float16 +.. function:: log10(x: float64) -> float64 Return the natural log (base-10) of x, where x is positive. -.. function:: log10(x: float64) -> float64 +.. function:: log10(x: float32) -> float32 Return the natural log (base-10) of x, where x is positive. -.. function:: log10(x: float32) -> float32 +.. function:: log10(x: float16) -> float16 Return the natural log (base-10) of x, where x is positive. @@ -998,17 +998,17 @@ Scalar Math Return the natural log (base-10) of x, where x is positive. -.. function:: exp(x: float16) -> float16 +.. function:: exp(x: float64) -> float64 Return base-e exponential, e^x. -.. function:: exp(x: float64) -> float64 +.. function:: exp(x: float32) -> float32 Return base-e exponential, e^x. -.. function:: exp(x: float32) -> float32 +.. function:: exp(x: float16) -> float16 Return base-e exponential, e^x. @@ -1018,17 +1018,17 @@ Scalar Math Return base-e exponential, e^x. -.. function:: pow(x: float16, y: float16) -> float16 +.. function:: pow(x: float64, y: float64) -> float64 Return the result of x raised to power of y. -.. function:: pow(x: float64, y: float64) -> float64 +.. function:: pow(x: float32, y: float32) -> float32 Return the result of x raised to power of y. -.. function:: pow(x: float32, y: float32) -> float32 +.. function:: pow(x: float16, y: float16) -> float16 Return the result of x raised to power of y. @@ -1038,21 +1038,21 @@ Scalar Math Return the result of x raised to power of y. -.. function:: round(x: float16) -> float16 +.. function:: round(x: float64) -> float64 Calculate the nearest integer value, 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()``. -.. function:: round(x: float64) -> float64 +.. function:: round(x: float32) -> float32 Calculate the nearest integer value, 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()``. -.. function:: round(x: float32) -> float32 +.. function:: round(x: float16) -> float16 Calculate the nearest integer value, 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()``. @@ -1066,21 +1066,21 @@ This is the most intuitive form of rounding in the colloquial sense, but can be Differs from ``numpy.round()``, which behaves the same way as ``numpy.rint()``. -.. function:: rint(x: float16) -> float16 +.. function:: rint(x: float64) -> float64 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: rint(x: float64) -> float64 +.. function:: rint(x: float32) -> float32 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: rint(x: float32) -> float32 +.. function:: rint(x: float16) -> float16 Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. @@ -1094,7 +1094,7 @@ It is generally faster than ``warp.round()``. Equivalent to ``numpy.rint()``. -.. function:: trunc(x: float16) -> float16 +.. function:: trunc(x: float64) -> float64 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1102,7 +1102,7 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: trunc(x: float64) -> float64 +.. function:: trunc(x: float32) -> float32 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1110,7 +1110,7 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: trunc(x: float32) -> float32 +.. function:: trunc(x: float16) -> float16 Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1126,17 +1126,17 @@ It is similar to casting ``float(int(x))``, but preserves the negative sign when Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. -.. function:: floor(x: float16) -> float16 +.. function:: floor(x: float64) -> float64 Calculate the largest integer that is less than or equal to x. -.. function:: floor(x: float64) -> float64 +.. function:: floor(x: float32) -> float32 Calculate the largest integer that is less than or equal to x. -.. function:: floor(x: float32) -> float32 +.. function:: floor(x: float16) -> float16 Calculate the largest integer that is less than or equal to x. @@ -1146,17 +1146,17 @@ Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. Calculate the largest integer that is less than or equal to x. -.. function:: ceil(x: float16) -> float16 +.. function:: ceil(x: float64) -> float64 Calculate the smallest integer that is greater than or equal to x. -.. function:: ceil(x: float64) -> float64 +.. function:: ceil(x: float32) -> float32 Calculate the smallest integer that is greater than or equal to x. -.. function:: ceil(x: float32) -> float32 +.. function:: ceil(x: float16) -> float16 Calculate the smallest integer that is greater than or equal to x. @@ -1170,1741 +1170,1741 @@ Equivalent to ``numpy.trunc()`` and ``numpy.fix()``. Vector Math --------------- -.. function:: dot(x: vec2h, y: vec2h) -> float16 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec3h, y: vec3h) -> float16 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec4h, y: vec4h) -> float16 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float64 Compute the dot product between two vectors. -.. function:: dot(x: vec2d, y: vec2d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3d, y: vec3d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec4d, y: vec4d) -> float64 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2ub, y: vec2ub) -> uint8 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3ub, y: vec3ub) -> uint8 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec4ub, y: vec4ub) -> uint8 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2f, y: vec2f) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2f, y: vec2) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2, y: vec2f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec2, y: vec2) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3f, y: vec3f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3f, y: vec3) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float32 Compute the dot product between two vectors. -.. function:: dot(x: vec3, y: vec3f) -> float32 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec3, y: vec3) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec4f, y: vec4f) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> uint8 Compute the dot product between two vectors. -.. function:: dot(x: vec4f, y: vec4) -> float32 +.. function:: dot(x: vec[2, ], y: vec[2, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vec4, y: vec4f) -> float32 +.. function:: dot(x: vec[3, ], y: vec[3, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vec4, y: vec4) -> float32 +.. function:: dot(x: vec[4, ], y: vec[4, ]) -> float16 Compute the dot product between two vectors. -.. function:: dot(x: vector_t, y: vector_t) -> Scalar +.. function:: dot(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> Scalar Compute the dot product between two vectors. -.. function:: dot(x: quath, y: quath) -> float16 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float64 Compute the dot product between two quaternions. -.. function:: dot(x: quatd, y: quatd) -> float64 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quatf, y: quatf) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quatf, y: quat) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quat, y: quatf) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float32 Compute the dot product between two quaternions. -.. function:: dot(x: quat, y: quat) -> float32 +.. function:: dot(x: quaternion[], y: quaternion[]) -> float16 Compute the dot product between two quaternions. -.. function:: dot(x: vector_t, y: vector_t) -> Scalar +.. function:: dot(x: quaternion[~Float], y: quaternion[~Float]) -> Scalar Compute the dot product between two quaternions. -.. function:: ddot(x: mat22h, y: mat22h) -> float16 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33h, y: mat33h) -> float16 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44h, y: mat44h) -> float16 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float64 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22d, y: mat22d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33d, y: mat33d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44d, y: mat44d) -> float64 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22f, y: mat22f) -> float32 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22f, y: mat22) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22, y: mat22f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat22, y: mat22) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33f, y: mat33f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33f, y: mat33) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33, y: mat33f) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat33, y: mat33) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44f, y: mat44f) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44f, y: mat44) -> float32 +.. function:: ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44, y: mat44f) -> float32 +.. function:: ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: mat44, y: mat44) -> float32 +.. function:: ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float16 Compute the double dot product between two matrices. -.. function:: ddot(x: matrix_t, y: matrix_t) -> Scalar +.. function:: ddot(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Compute the double dot product between two matrices. -.. function:: outer(x: vec2h, y: vec2h) -> mat22h +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3h, y: vec3h) -> mat33h +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4h, y: vec4h) -> mat44h +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2d, y: vec2d) -> mat22d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3d, y: vec3d) -> mat33d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4d, y: vec4d) -> mat44d +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2f, y: vec2f) -> mat22f +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2f, y: vec2) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2, y: vec2f) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec2, y: vec2) -> mat22f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3f, y: vec3f) -> mat33f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3f, y: vec3) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3, y: vec3f) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec3, y: vec3) -> mat33f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4f, y: vec4f) -> mat44f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4f, y: vec4) -> mat44f +.. function:: outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4, y: vec4f) -> mat44f +.. function:: outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vec4, y: vec4) -> mat44f +.. function:: outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: vector_t, y: vector_t) -> matrix_t +.. function:: outer(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Compute the outer product x*y^T for two vec2 objects. -.. function:: outer(x: spatial_vectorh, y: spatial_vectorh) -> spatial_matrixh +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectord, y: spatial_vectord) -> spatial_matrixd +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectorf, y: spatial_vectorf) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vectorf, y: spatial_vector) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vector, y: spatial_vectorf) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: spatial_vector, y: spatial_vector) -> spatial_matrixf +.. function:: outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: outer(x: vector_t, y: vector_t) -> matrix_t +.. function:: outer(x: spatial_vector_t[~Float], y: spatial_vector_t[~Float]) -> spatial_matrix_t[~Float] Compute the outer product x*y^T for two spatial_vector objects. -.. function:: cross(x: vec3h, y: vec3h) -> vec3h +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3d, y: vec3d) -> vec3d +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3f, y: vec3f) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3f, y: vec3) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3, y: vec3f) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vec3, y: vec3) -> vec3f +.. function:: cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Compute the cross product of two 3d vectors. -.. function:: cross(x: vector_t, y: vector_t) -> vector_t +.. function:: cross(x: vec[3, ~Scalar], y: vec[3, ~Scalar]) -> vec[3, ~Scalar] Compute the cross product of two 3d vectors. -.. function:: skew(x: vec3h) -> mat33h +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3d) -> mat33d +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3f) -> mat33f +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vec3) -> mat33f +.. function:: skew(x: vec[3, ]) -> mat[3, 3, ] Compute the skew symmetric matrix for a 3d vector. -.. function:: skew(x: vector_t) +.. function:: skew(x: vec[3, ~Scalar]) Compute the skew symmetric matrix for a 3d vector. -.. function:: length(x: vec2h) -> float16 +.. function:: length(x: vec[2, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec3h) -> float16 +.. function:: length(x: vec[3, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec4h) -> float16 +.. function:: length(x: vec[4, ]) -> float64 Compute the length of a vector. -.. function:: length(x: vec2d) -> float64 +.. function:: length(x: vec[2, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3d) -> float64 +.. function:: length(x: vec[2, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec4d) -> float64 +.. function:: length(x: vec[3, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec2f) -> float32 +.. function:: length(x: vec[3, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec2) -> float32 +.. function:: length(x: vec[4, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3f) -> float32 +.. function:: length(x: vec[4, ]) -> float32 Compute the length of a vector. -.. function:: length(x: vec3) -> float32 +.. function:: length(x: vec[2, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vec4f) -> float32 +.. function:: length(x: vec[3, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vec4) -> float32 +.. function:: length(x: vec[4, ]) -> float16 Compute the length of a vector. -.. function:: length(x: vector_t) -> Scalar +.. function:: length(x: vec[typing.Any, ~Float]) -> Scalar Compute the length of a vector. -.. function:: length(x: quath) -> float16 +.. function:: length(x: quaternion[]) -> float64 Compute the length of a quaternion. -.. function:: length(x: quatd) -> float64 +.. function:: length(x: quaternion[]) -> float32 Compute the length of a quaternion. -.. function:: length(x: quatf) -> float32 +.. function:: length(x: quaternion[]) -> float32 Compute the length of a quaternion. -.. function:: length(x: quat) -> float32 +.. function:: length(x: quaternion[]) -> float16 Compute the length of a quaternion. -.. function:: length(x: vector_t) -> Scalar +.. function:: length(x: quaternion[~Float]) -> Scalar Compute the length of a quaternion. -.. function:: length_sq(x: vec2h) -> float16 +.. function:: length_sq(x: vec[2, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3h) -> float16 +.. function:: length_sq(x: vec[3, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4h) -> float16 +.. function:: length_sq(x: vec[4, ]) -> float64 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2d) -> float64 +.. function:: length_sq(x: vec[2, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3d) -> float64 +.. function:: length_sq(x: vec[2, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4d) -> float64 +.. function:: length_sq(x: vec[3, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2ub) -> uint8 +.. function:: length_sq(x: vec[3, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3ub) -> uint8 +.. function:: length_sq(x: vec[4, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4ub) -> uint8 +.. function:: length_sq(x: vec[4, ]) -> float32 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2f) -> float32 +.. function:: length_sq(x: vec[2, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec2) -> float32 +.. function:: length_sq(x: vec[3, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3f) -> float32 +.. function:: length_sq(x: vec[4, ]) -> uint8 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec3) -> float32 +.. function:: length_sq(x: vec[2, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4f) -> float32 +.. function:: length_sq(x: vec[3, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vec4) -> float32 +.. function:: length_sq(x: vec[4, ]) -> float16 Compute the squared length of a 2d vector. -.. function:: length_sq(x: vector_t) -> Scalar +.. function:: length_sq(x: vec[typing.Any, ~Scalar]) -> Scalar Compute the squared length of a 2d vector. -.. function:: length_sq(x: quath) -> float16 +.. function:: length_sq(x: quaternion[]) -> float64 Compute the squared length of a quaternion. -.. function:: length_sq(x: quatd) -> float64 +.. function:: length_sq(x: quaternion[]) -> float32 Compute the squared length of a quaternion. -.. function:: length_sq(x: quatf) -> float32 +.. function:: length_sq(x: quaternion[]) -> float32 Compute the squared length of a quaternion. -.. function:: length_sq(x: quat) -> float32 +.. function:: length_sq(x: quaternion[]) -> float16 Compute the squared length of a quaternion. -.. function:: length_sq(x: vector_t) -> Scalar +.. function:: length_sq(x: quaternion[~Scalar]) -> Scalar Compute the squared length of a quaternion. -.. function:: normalize(x: vec2h) -> vec2h +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3h) -> vec3h +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4h) -> vec4h +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2d) -> vec2d +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3d) -> vec3d +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4d) -> vec4d +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2f) -> vec2f +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec2) -> vec2f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3f) -> vec3f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec3) -> vec3f +.. function:: normalize(x: vec[2, ]) -> vec[2, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4f) -> vec4f +.. function:: normalize(x: vec[3, ]) -> vec[3, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vec4) -> vec4f +.. function:: normalize(x: vec[4, ]) -> vec[4, ] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: vector_t) -> vector_t +.. function:: normalize(x: vec[typing.Any, ~Float]) -> vec[typing.Any, ~Scalar] Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. -.. function:: normalize(x: quath) -> quath +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quatd) -> quatd +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quatf) -> quatf +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: quat) -> quatf +.. function:: normalize(x: quaternion[]) -> quaternion[] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: normalize(x: vector_t) -> vector_t +.. function:: normalize(x: quaternion[~Float]) -> quaternion[~Scalar] Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. -.. function:: transpose(m: mat22h) -> mat22h +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33h) -> mat33h +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44h) -> mat44h +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22d) -> mat22d +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33d) -> mat33d +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44d) -> mat44d +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22f) -> mat22f +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat22) -> mat22f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33f) -> mat33f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: mat33) -> mat33f +.. function:: transpose(m: mat[2, 2, ]) -> mat[2, 2, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44f) -> mat44f +.. function:: transpose(m: mat[3, 3, ]) -> mat[3, 3, ] Return the transpose of the matrix m -.. function:: transpose(m: mat44) -> mat44f +.. function:: transpose(m: mat[4, 4, ]) -> mat[4, 4, ] Return the transpose of the matrix m -.. function:: transpose(m: matrix_t) +.. function:: transpose(m: mat[typing.Any, typing.Any, ~Scalar]) Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixh) -> spatial_matrixh +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixd) -> spatial_matrixd +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrixf) -> spatial_matrixf +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: spatial_matrix) -> spatial_matrixf +.. function:: transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[] Return the transpose of the matrix m -.. function:: transpose(m: matrix_t) -> matrix_t +.. function:: transpose(m: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] Return the transpose of the matrix m -.. function:: inverse(m: mat22h) -> mat22h +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33h) -> mat33h +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44h) -> mat44h +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22d) -> mat22d +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33d) -> mat33d +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44d) -> mat44d +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22f) -> mat22f +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat22) -> mat22f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33f) -> mat33f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: mat33) -> mat33f +.. function:: inverse(m: mat[2, 2, ]) -> mat[2, 2, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44f) -> mat44f +.. function:: inverse(m: mat[3, 3, ]) -> mat[3, 3, ] Return the inverse of the matrix m -.. function:: inverse(m: mat44) -> mat44f +.. function:: inverse(m: mat[4, 4, ]) -> mat[4, 4, ] Return the inverse of the matrix m -.. function:: inverse(m: matrix_t) -> matrix_t +.. function:: inverse(m: mat[typing.Any, typing.Any, ~Float]) -> mat[typing.Any, typing.Any, ~Float] Return the inverse of the matrix m -.. function:: determinant(m: mat22h) -> float16 +.. function:: determinant(m: mat[2, 2, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat33h) -> float16 +.. function:: determinant(m: mat[3, 3, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat44h) -> float16 +.. function:: determinant(m: mat[4, 4, ]) -> float64 Return the determinant of the matrix m -.. function:: determinant(m: mat22d) -> float64 +.. function:: determinant(m: mat[2, 2, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33d) -> float64 +.. function:: determinant(m: mat[2, 2, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat44d) -> float64 +.. function:: determinant(m: mat[3, 3, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat22f) -> float32 +.. function:: determinant(m: mat[3, 3, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat22) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33f) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float32 Return the determinant of the matrix m -.. function:: determinant(m: mat33) -> float32 +.. function:: determinant(m: mat[2, 2, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: mat44f) -> float32 +.. function:: determinant(m: mat[3, 3, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: mat44) -> float32 +.. function:: determinant(m: mat[4, 4, ]) -> float16 Return the determinant of the matrix m -.. function:: determinant(m: matrix_t) -> Scalar +.. function:: determinant(m: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Return the determinant of the matrix m -.. function:: trace(m: mat22h) -> float16 +.. function:: trace(m: mat[2, 2, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat33h) -> float16 +.. function:: trace(m: mat[3, 3, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat44h) -> float16 +.. function:: trace(m: mat[4, 4, ]) -> float64 Return the trace of the matrix m -.. function:: trace(m: mat22d) -> float64 +.. function:: trace(m: mat[2, 2, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33d) -> float64 +.. function:: trace(m: mat[2, 2, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat44d) -> float64 +.. function:: trace(m: mat[3, 3, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat22f) -> float32 +.. function:: trace(m: mat[3, 3, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat22) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33f) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float32 Return the trace of the matrix m -.. function:: trace(m: mat33) -> float32 +.. function:: trace(m: mat[2, 2, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: mat44f) -> float32 +.. function:: trace(m: mat[3, 3, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: mat44) -> float32 +.. function:: trace(m: mat[4, 4, ]) -> float16 Return the trace of the matrix m -.. function:: trace(m: matrix_t) -> Scalar +.. function:: trace(m: mat[typing.Any, typing.Any, ~Scalar]) -> Scalar Return the trace of the matrix m -.. function:: diag(d: vec2h) -> mat22h +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3h) -> mat33h +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4h) -> mat44h +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2d) -> mat22d +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3d) -> mat33d +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4d) -> mat44d +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2f) -> mat22f +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec2) -> mat22f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3f) -> mat33f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec3) -> mat33f +.. function:: diag(d: vec[2, ]) -> mat[2, 2, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4f) -> mat44f +.. function:: diag(d: vec[3, ]) -> mat[3, 3, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vec4) -> mat44f +.. function:: diag(d: vec[4, ]) -> mat[4, 4, ] Returns a matrix with the components of the vector d on the diagonal -.. function:: diag(d: vector_t) +.. function:: diag(d: vec[typing.Any, ~Scalar]) Returns a matrix with the components of the vector d on the diagonal -.. function:: cw_mul(x: vec2h, y: vec2h) -> vec2h +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3h, y: vec3h) -> vec3h +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4h, y: vec4h) -> vec4h +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2d, y: vec2d) -> vec2d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3d, y: vec3d) -> vec3d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4d, y: vec4d) -> vec4d +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2f, y: vec2f) -> vec2f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2f, y: vec2) -> vec2f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2, y: vec2f) -> vec2f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec2, y: vec2) -> vec2f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3f, y: vec3f) -> vec3f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3f, y: vec3) -> vec3f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3, y: vec3f) -> vec3f +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec3, y: vec3) -> vec3f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4f, y: vec4f) -> vec4f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4f, y: vec4) -> vec4f +.. function:: cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4, y: vec4f) -> vec4f +.. function:: cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vec4, y: vec4) -> vec4f +.. function:: cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: vector_t, y: vector_t) -> vector_t +.. function:: cw_mul(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22h, y: mat22h) -> mat22h +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33h, y: mat33h) -> mat33h +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44h, y: mat44h) -> mat44h +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22d, y: mat22d) -> mat22d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33d, y: mat33d) -> mat33d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44d, y: mat44d) -> mat44d +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22f, y: mat22f) -> mat22f +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22f, y: mat22) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22, y: mat22f) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat22, y: mat22) -> mat22f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33f, y: mat33f) -> mat33f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33f, y: mat33) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33, y: mat33f) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat33, y: mat33) -> mat33f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44f, y: mat44f) -> mat44f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44f, y: mat44) -> mat44f +.. function:: cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44, y: mat44f) -> mat44f +.. function:: cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: mat44, y: mat44) -> mat44f +.. function:: cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise multiply of two 2d vectors. -.. function:: cw_mul(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: cw_mul(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Component wise multiply of two 2d vectors. -.. function:: cw_div(x: vec2h, y: vec2h) -> vec2h +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3h, y: vec3h) -> vec3h +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4h, y: vec4h) -> vec4h +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2d, y: vec2d) -> vec2d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3d, y: vec3d) -> vec3d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4d, y: vec4d) -> vec4d +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2f, y: vec2f) -> vec2f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2f, y: vec2) -> vec2f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2, y: vec2f) -> vec2f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec2, y: vec2) -> vec2f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3f, y: vec3f) -> vec3f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3f, y: vec3) -> vec3f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3, y: vec3f) -> vec3f +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec3, y: vec3) -> vec3f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4f, y: vec4f) -> vec4f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4f, y: vec4) -> vec4f +.. function:: cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4, y: vec4f) -> vec4f +.. function:: cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vec4, y: vec4) -> vec4f +.. function:: cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: vector_t, y: vector_t) -> vector_t +.. function:: cw_div(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22h, y: mat22h) -> mat22h +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33h, y: mat33h) -> mat33h +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44h, y: mat44h) -> mat44h +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22d, y: mat22d) -> mat22d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33d, y: mat33d) -> mat33d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44d, y: mat44d) -> mat44d +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22f, y: mat22f) -> mat22f +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22f, y: mat22) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22, y: mat22f) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat22, y: mat22) -> mat22f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33f, y: mat33f) -> mat33f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33f, y: mat33) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33, y: mat33f) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat33, y: mat33) -> mat33f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44f, y: mat44f) -> mat44f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44f, y: mat44) -> mat44f +.. function:: cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44, y: mat44f) -> mat44f +.. function:: cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: mat44, y: mat44) -> mat44f +.. function:: cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] Component wise division of two 2d vectors. -.. function:: cw_div(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: cw_div(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] Component wise division of two 2d vectors. -.. function:: vec() -> vector_t +.. function:: vec() -> vec[typing.Any, ~Scalar] Construct a zero-initialized vector. -.. function:: vec(s: Scalar) -> vector_t +.. function:: vec(s: Scalar) -> vec[typing.Any, ~Scalar] Construct a vector with all components set to s. -.. function:: vec() -> vector_t +.. function:: vec() -> vec[typing.Any, ~Scalar] Construct a vector from scalar compontents. -.. function:: mat() -> matrix_t +.. function:: mat() -> mat[typing.Any, typing.Any, ~Scalar] Construct a zero matrix -.. function:: mat(s: Scalar) -> matrix_t +.. function:: mat(s: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] Construct a matrix with all components set to s -.. function:: mat(pos: vector_t, rot: vector_t, scale: vector_t) -> matrix_t +.. function:: mat(pos: vec[3, ~Float], rot: quaternion[~Float], scale: vec[3, ~Float]) -> mat[typing.Any, typing.Any, ~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 -.. function:: mat() -> matrix_t +.. function:: mat() -> mat[typing.Any, typing.Any, ~Scalar] Construct a matrix from components or column vectors. -.. function:: svd3(A: mat33h, U: mat33h, sigma: vec3h, V: mat33h) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33d, U: mat33d, sigma: vec3d, V: mat33d) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3, V: mat33f) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: mat33, U: mat33, sigma: vec3, V: mat33) -> None +.. function:: svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: svd3(A: matrix_t, U: matrix_t, sigma: vector_t, V: matrix_t) -> None +.. function:: svd3(A: mat[3, 3, ~Float], U: mat[3, 3, ~Float], sigma: vec[3, ~Float], V: mat[3, 3, ~Scalar]) -> None Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. -.. function:: qr3(A: mat33h, Q: mat33h, R: mat33h) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33d, Q: mat33d, R: mat33d) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33f, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33f, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33f, Q: mat33, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33f, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33f, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33, R: mat33f) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: mat33, Q: mat33, R: mat33) -> None +.. function:: qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: qr3(A: matrix_t, Q: matrix_t, R: matrix_t) -> None +.. function:: qr3(A: mat[3, 3, ~Float], Q: mat[3, 3, ~Float], R: mat[3, 3, ~Float]) -> None Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. -.. function:: eig3(A: mat33h, Q: mat33h, d: vec3h) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33d, Q: mat33d, d: vec3d) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33f, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33f, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33f, Q: mat33, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33f, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33f, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33, d: vec3f) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: mat33, Q: mat33, d: vec3) -> None +.. function:: eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. -.. function:: eig3(A: matrix_t, Q: matrix_t, d: vector_t) -> None +.. function:: eig3(A: mat[3, 3, ~Float], Q: mat[3, 3, ~Float], d: vec[3, ~Float]) -> None Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. @@ -2913,283 +2913,283 @@ Vector Math Quaternion Math --------------- -.. function:: quaternion() -> vector_t +.. function:: 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. -.. function:: quaternion(x: Float, y: Float, z: Float, w: Float) -> vector_t +.. function:: quaternion(x: Float, y: Float, z: Float, w: Float) -> quaternion[~Float] Construct a quarternion from its components x, y, z are the imaginary parts, w is the real part. -.. function:: quaternion(i: vector_t, r: Float) -> vector_t +.. function:: quaternion(i: vec[3, ~Float], r: Float) -> quaternion[~Float] Construct a quaternion from it's imaginary components i, and real part r -.. function:: quat_identity() -> quat +.. function:: quat_identity() -> quaternion[] Construct a float32 identity quaternion with zero imaginary part and real part of 1.0 -.. function:: quat_from_axis_angle(axis: vec3h, angle: float16) -> quath +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float64) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3d, angle: float64) -> quatd +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float16) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3f, angle: float32) -> quatf +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vec3, angle: float32) -> quatf +.. function:: quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_from_axis_angle(axis: vector_t, angle: Float) -> vector_t +.. function:: quat_from_axis_angle(axis: vec[3, ~Float], angle: Float) -> quaternion[~Scalar] Construct a quaternion representing a rotation of angle radians around the given axis. -.. function:: quat_to_axis_angle(q: quath, axis: vec3h, angle: float16) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float64) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatd, axis: vec3d, angle: float64) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatf, axis: vec3f, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quatf, axis: vec3, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quat, axis: vec3f, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: quat, axis: vec3, angle: float32) -> None +.. function:: quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float16) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_to_axis_angle(q: vector_t, axis: vector_t, angle: Float) -> None +.. function:: quat_to_axis_angle(q: quaternion[~Float], axis: vec[3, ~Float], angle: Float) -> None Extract the rotation axis and angle radians a quaternion represents. -.. function:: quat_from_matrix(m: mat33h) -> quath +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33d) -> quatd +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33f) -> quatf +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: mat33) -> quatf +.. function:: quat_from_matrix(m: mat[3, 3, ]) -> quaternion[] Construct a quaternion from a 3x3 matrix. -.. function:: quat_from_matrix(m: matrix_t) -> vector_t +.. function:: quat_from_matrix(m: mat[3, 3, ~Float]) -> quaternion[~Scalar] Construct a quaternion from a 3x3 matrix. -.. function:: quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quath +.. function:: quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quatd +.. function:: quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quatf +.. function:: quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quaternion[] Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. -.. function:: quat_rpy(roll: Float, pitch: Float, yaw: Float) -> vector_t +.. function:: 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. -.. function:: quat_inverse(q: quath) -> quath +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quatd) -> quatd +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quatf) -> quatf +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: quat) -> quatf +.. function:: quat_inverse(q: quaternion[]) -> quaternion[] Compute quaternion conjugate. -.. function:: quat_inverse(q: vector_t) -> vector_t +.. function:: quat_inverse(q: quaternion[~Float]) -> quaternion[~Scalar] Compute quaternion conjugate. -.. function:: quat_rotate(q: quath, p: vec3h) -> vec3h +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatd, p: vec3d) -> vec3d +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatf, p: vec3f) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quatf, p: vec3) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quat, p: vec3f) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: quat, p: vec3) -> vec3f +.. function:: quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector by a quaternion. -.. function:: quat_rotate(q: vector_t, p: vector_t) -> vector_t +.. function:: quat_rotate(q: quaternion[~Float], p: vec[3, ~Float]) -> vec[3, ~Scalar] Rotate a vector by a quaternion. -.. function:: quat_rotate_inv(q: quath, p: vec3h) -> vec3h +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatd, p: vec3d) -> vec3d +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatf, p: vec3f) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quatf, p: vec3) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quat, p: vec3f) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: quat, p: vec3) -> vec3f +.. function:: quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ] Rotate a vector the inverse of a quaternion. -.. function:: quat_rotate_inv(q: vector_t, p: vector_t) -> vector_t +.. function:: quat_rotate_inv(q: quaternion[~Float], p: vec[3, ~Float]) -> vec[3, ~Scalar] Rotate a vector the inverse of a quaternion. -.. function:: quat_slerp(q0: quath, q1: quath, t: float16) -> quath +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float64) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatd, q1: quatd, t: float64) -> quatd +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float16) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatf, q1: quatf, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quatf, q1: quat, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quat, q1: quatf, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: quat, q1: quat, t: float32) -> quatf +.. function:: quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[] Linearly interpolate between two quaternions. -.. function:: quat_slerp(q0: vector_t, q1: vector_t, t: Float) -> vector_t +.. function:: quat_slerp(q0: quaternion[~Float], q1: quaternion[~Float], t: Float) -> quaternion[~Scalar] Linearly interpolate between two quaternions. -.. function:: quat_to_matrix(q: quath) -> mat33h +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quatd) -> mat33d +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quatf) -> mat33f +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: quat) -> mat33f +.. function:: quat_to_matrix(q: quaternion[]) -> mat[3, 3, ] Convert a quaternion to a 3x3 rotation matrix. -.. function:: quat_to_matrix(q: vector_t) -> matrix_t +.. function:: quat_to_matrix(q: quaternion[~Float]) -> mat[3, 3, ~Scalar] Convert a quaternion to a 3x3 rotation matrix. @@ -3198,290 +3198,290 @@ Quaternion Math Transformations --------------- -.. function:: transform_t(p: vector_t, q: vector_t) -> transform_class +.. function:: transform_t(p: vec[3, ~Float], q: quaternion[~Float]) -> transform_t[~Scalar] Construct a rigid body transformation with translation part p and rotation q. -.. function:: transform_identity() -> transform +.. function:: transform_identity() -> transform_t[] Construct a float32 identity transform with zero translation and identity rotation. -.. function:: transform_get_translation(t: transformh) -> vec3h +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transformd) -> vec3d +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transformf) -> vec3f +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transform) -> vec3f +.. function:: transform_get_translation(t: transform_t[]) -> vec[3, ] Return the translational part of a transform. -.. function:: transform_get_translation(t: transform_class) -> vector_t +.. function:: transform_get_translation(t: transform_t[~Float]) -> vec[3, ~Scalar] Return the translational part of a transform. -.. function:: transform_get_rotation(t: transformh) -> quath +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transformd) -> quatd +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transformf) -> quatf +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transform) -> quatf +.. function:: transform_get_rotation(t: transform_t[]) -> quaternion[] Return the rotational part of a transform. -.. function:: transform_get_rotation(t: transform_class) -> vector_t +.. function:: transform_get_rotation(t: transform_t[~Float]) -> quaternion[~Scalar] Return the rotational part of a transform. -.. function:: transform_multiply(a: transformh, b: transformh) -> transformh +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformd, b: transformd) -> transformd +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformf, b: transformf) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transformf, b: transform) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform, b: transformf) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform, b: transform) -> transformf +.. function:: transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[] Multiply two rigid body transformations together. -.. function:: transform_multiply(a: transform_class, b: transform_class) -> transform_class +.. function:: transform_multiply(a: transform_t[~Float], b: transform_t[~Float]) -> transform_t[~Scalar] Multiply two rigid body transformations together. -.. function:: transform_point(t: transformh, p: vec3h) -> vec3h +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformd, p: vec3d) -> vec3d +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformf, p: vec3f) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transformf, p: vec3) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform, p: vec3f) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform, p: vec3) -> vec3f +.. function:: transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(t: transform_class, p: vector_t) -> vector_t +.. function:: transform_point(t: transform_t[~Scalar], p: vec[3, ~Scalar]) -> vec[3, ~Scalar] Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). -.. function:: transform_point(m: mat44h, p: vec3h) -> vec3h +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44d, p: vec3d) -> vec3d +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44f, p: vec3f) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44f, p: vec3) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44, p: vec3f) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: mat44, p: vec3) -> vec3f +.. function:: transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_point(m: matrix_t, p: vector_t) -> vector_t +.. function:: transform_point(m: mat[4, 4, ~Scalar], p: vec[3, ~Scalar]) -> vec[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 tranformation matrix before calling this method. -.. function:: transform_vector(t: transformh, v: vec3h) -> vec3h +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformd, v: vec3d) -> vec3d +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformf, v: vec3f) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transformf, v: vec3) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform, v: vec3f) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform, v: vec3) -> vec3f +.. function:: transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(t: transform_class, v: vector_t) -> vector_t +.. function:: transform_vector(t: transform_t[~Scalar], v: vec[3, ~Scalar]) -> vec[3, ~Scalar] Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). -.. function:: transform_vector(m: mat44h, v: vec3h) -> vec3h +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44d, v: vec3d) -> vec3d +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44f, v: vec3f) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44f, v: vec3) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44, v: vec3f) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: mat44, v: vec3) -> vec3f +.. function:: transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ] 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 tranformation matrix before calling this method. -.. function:: transform_vector(m: matrix_t, v: vector_t) -> vector_t +.. function:: transform_vector(m: mat[4, 4, ~Scalar], v: vec[3, ~Scalar]) -> vec[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 tranformation matrix before calling this method. -.. function:: transform_inverse(t: transformh) -> transformh +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transformd) -> transformd +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transformf) -> transformf +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transform) -> transformf +.. function:: transform_inverse(t: transform_t[]) -> transform_t[] Compute the inverse of the transform. -.. function:: transform_inverse(t: transform_class) -> transform_class +.. function:: transform_inverse(t: transform_t[~Float]) -> transform_t[~Float] Compute the inverse of the transform. @@ -3490,200 +3490,200 @@ Transformations Spatial Math --------------- -.. function:: spatial_vector_t() -> vector_t +.. function:: spatial_vector_t() -> spatial_vector_t[~Float] Construct a zero-initialized 6d screw vector. Screw vectors may be used to represent rigid body wrenches and twists (velocites). -.. function:: spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) -> vector_t +.. function:: spatial_vector_t(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) -> spatial_vector_t[~Float] Construct a 6d screw vector from it's components. -.. function:: spatial_vector_t(w: vector_t, v: vector_t) -> vector_t +.. function:: spatial_vector_t(w: vec[3, ~Float], v: vec[3, ~Float]) -> spatial_vector_t[~Float] Construct a 6d screw vector from two 3d vectors. -.. function:: spatial_vector_t(s: Float) -> vector_t +.. function:: spatial_vector_t(s: Float) -> spatial_vector_t[~Float] Construct a 6d screw vector with all components set to s -.. function:: spatial_matrix_t() -> matrix_t +.. function:: spatial_matrix_t() -> spatial_matrix_t[~Float] Construct a 6x6 zero-initialized spatial inertia matrix -.. function:: spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) -> matrix_t +.. function:: spatial_matrix_t(s0: Scalar, s1: Scalar, s2: Scalar, s3: Scalar, s4: Scalar, s5: Scalar, s6: Scalar, s7: Scalar, s8: Scalar, s9: Scalar, s10: Scalar, s11: Scalar, s12: Scalar, s13: Scalar, s14: Scalar, s15: Scalar, s16: Scalar, s17: Scalar, s18: Scalar, s19: Scalar, s20: Scalar, s21: Scalar, s22: Scalar, s23: Scalar, s24: Scalar, s25: Scalar, s26: Scalar, s27: Scalar, s28: Scalar, s29: Scalar, s30: Scalar, s31: Scalar, s32: Scalar, s33: Scalar, s34: Scalar, s35: Scalar) -> spatial_matrix_t[~Float] Construct a 6x6 spatial inertia matrix from components -.. function:: spatial_adjoint(r: matrix_t, s: matrix_t) -> matrix_t +.. function:: spatial_adjoint(r: mat[3, 3, ~Float], s: mat[3, 3, ~Float]) -> spatial_matrix_t[~Scalar] Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks. -.. function:: spatial_dot(a: spatial_vectorh, b: spatial_vectorh) -> float16 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float64 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectord, b: spatial_vectord) -> float64 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectorf, b: spatial_vectorf) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vectorf, b: spatial_vector) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vector, b: spatial_vectorf) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: spatial_vector, b: spatial_vector) -> float32 +.. function:: spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float16 Compute the dot product of two 6d screw vectors. -.. function:: spatial_dot(a: vector_t, b: vector_t) -> Scalar +.. function:: spatial_dot(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> Scalar Compute the dot product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: spatial_vector, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross(a: vector_t, b: vector_t) -> vector_t +.. function:: spatial_cross(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> spatial_vector_t[~Float] Compute the cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: spatial_vector, b: spatial_vector) -> spatial_vectorf +.. function:: spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_cross_dual(a: vector_t, b: vector_t) -> vector_t +.. function:: spatial_cross_dual(a: spatial_vector_t[~Float], b: spatial_vector_t[~Float]) -> spatial_vector_t[~Float] Compute the dual cross-product of two 6d screw vectors. -.. function:: spatial_top(a: spatial_vectorh) -> vec3h +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vectord) -> vec3d +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vectorf) -> vec3f +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: spatial_vector) -> vec3f +.. function:: spatial_top(a: spatial_vector_t[]) -> vec[3, ] Return the top (first) part of a 6d screw vector. -.. function:: spatial_top(a: vector_t) +.. function:: spatial_top(a: spatial_vector_t[~Float]) Return the top (first) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectorh) -> vec3h +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectord) -> vec3d +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vectorf) -> vec3f +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: spatial_vector) -> vec3f +.. function:: spatial_bottom(a: spatial_vector_t[]) -> vec[3, ] Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_bottom(a: vector_t) +.. function:: spatial_bottom(a: spatial_vector_t[~Float]) Return the bottom (second) part of a 6d screw vector. -.. function:: spatial_jacobian(S: array[vector_t], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]) -> None +.. function:: spatial_jacobian(S: array[spatial_vector_t[~Float]], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]) -> None -.. function:: spatial_mass(I_s: array[matrix_t], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) -> None +.. function:: spatial_mass(I_s: array[spatial_matrix_t[~Float]], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]) -> None @@ -3875,467 +3875,467 @@ Utility Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quath, arg2: quath) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quatf, arg2: quatf) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quatd, arg2: quatd) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: quat, arg2: quat) -> None +.. function:: expect_eq(arg1: quaternion[], arg2: quaternion[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformh, arg2: transformh) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformf, arg2: transformf) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transformd, arg2: transformd) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: transform, arg2: transform) -> None +.. function:: expect_eq(arg1: transform_t[], arg2: transform_t[]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2h, arg2: vec2h) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3h, arg2: vec3h) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4h, arg2: vec4h) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2d, arg2: vec2d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3d, arg2: vec3d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4d, arg2: vec4d) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2ub, arg2: vec2ub) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3ub, arg2: vec3ub) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4ub, arg2: vec4ub) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2f, arg2: vec2f) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2f, arg2: vec2) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2, arg2: vec2f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec2, arg2: vec2) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3f, arg2: vec3f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3f, arg2: vec3) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3, arg2: vec3f) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec3, arg2: vec3) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4f, arg2: vec4f) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4f, arg2: vec4) -> None +.. function:: expect_eq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4, arg2: vec4f) -> None +.. function:: expect_eq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vec4, arg2: vec4) -> None +.. function:: expect_eq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: vector_t, arg2: vector_t) +.. function:: expect_eq(arg1: vec[typing.Any, ~Scalar], arg2: vec[typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22h, arg2: mat22h) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33h, arg2: mat33h) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44h, arg2: mat44h) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22d, arg2: mat22d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33d, arg2: mat33d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44d, arg2: mat44d) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22f, arg2: mat22f) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22f, arg2: mat22) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22, arg2: mat22f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat22, arg2: mat22) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33f, arg2: mat33f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33f, arg2: mat33) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33, arg2: mat33f) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat33, arg2: mat33) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44f, arg2: mat44f) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44f, arg2: mat44) -> None +.. function:: expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44, arg2: mat44f) -> None +.. function:: expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: mat44, arg2: mat44) -> None +.. function:: expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_eq(arg1: matrix_t, arg2: matrix_t) +.. function:: expect_eq(arg1: mat[typing.Any, typing.Any, ~Scalar], arg2: mat[typing.Any, typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are not equal -.. function:: expect_neq(arg1: vec2h, arg2: vec2h) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3h, arg2: vec3h) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4h, arg2: vec4h) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2d, arg2: vec2d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3d, arg2: vec3d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4d, arg2: vec4d) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2ub, arg2: vec2ub) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3ub, arg2: vec3ub) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4ub, arg2: vec4ub) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2f, arg2: vec2f) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2f, arg2: vec2) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2, arg2: vec2f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec2, arg2: vec2) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3f, arg2: vec3f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3f, arg2: vec3) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3, arg2: vec3f) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec3, arg2: vec3) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4f, arg2: vec4f) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4f, arg2: vec4) -> None +.. function:: expect_neq(arg1: vec[2, ], arg2: vec[2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4, arg2: vec4f) -> None +.. function:: expect_neq(arg1: vec[3, ], arg2: vec[3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vec4, arg2: vec4) -> None +.. function:: expect_neq(arg1: vec[4, ], arg2: vec[4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: vector_t, arg2: vector_t) +.. function:: expect_neq(arg1: vec[typing.Any, ~Scalar], arg2: vec[typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22h, arg2: mat22h) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33h, arg2: mat33h) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44h, arg2: mat44h) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22d, arg2: mat22d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33d, arg2: mat33d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44d, arg2: mat44d) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22f, arg2: mat22f) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22f, arg2: mat22) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22, arg2: mat22f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat22, arg2: mat22) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33f, arg2: mat33f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33f, arg2: mat33) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33, arg2: mat33f) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat33, arg2: mat33) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44f, arg2: mat44f) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44f, arg2: mat44) -> None +.. function:: expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44, arg2: mat44f) -> None +.. function:: expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: mat44, arg2: mat44) -> None +.. function:: expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]) -> None Prints an error to stdout if arg1 and arg2 are equal -.. function:: expect_neq(arg1: matrix_t, arg2: matrix_t) +.. function:: expect_neq(arg1: mat[typing.Any, typing.Any, ~Scalar], arg2: mat[typing.Any, typing.Any, ~Scalar]) Prints an error to stdout if arg1 and arg2 are equal -.. function:: lerp(a: float16, b: float16, t: float16) -> float16 +.. function:: lerp(a: float64, b: float64, t: float64) -> float64 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: float64, b: float64, t: float64) -> float64 +.. function:: lerp(a: float32, b: float32, t: float32) -> float32 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: float32, b: float32, t: float32) -> float32 +.. function:: lerp(a: float16, b: float16, t: float16) -> float16 Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` @@ -4345,217 +4345,217 @@ Utility Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2h, b: vec2h, t: float16) -> vec2h +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float16) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2f, b: vec2f, t: float32) -> vec2f +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2d, b: vec2d, t: float64) -> vec2d +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float64) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec2, b: vec2, t: float32) -> vec2 +.. function:: lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3h, b: vec3h, t: float16) -> vec3h +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float16) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3f, b: vec3f, t: float32) -> vec3f +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3d, b: vec3d, t: float64) -> vec3d +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float64) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec3, b: vec3, t: float32) -> vec3 +.. function:: lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4h, b: vec4h, t: float16) -> vec4h +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float16) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4f, b: vec4f, t: float32) -> vec4f +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4d, b: vec4d, t: float64) -> vec4d +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float64) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: vec4, b: vec4, t: float32) -> vec4 +.. function:: lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22h, b: mat22h, t: float16) -> mat22h +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float16) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22f, b: mat22f, t: float32) -> mat22f +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22d, b: mat22d, t: float64) -> mat22d +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float64) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat22, b: mat22, t: float32) -> mat22 +.. function:: lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33h, b: mat33h, t: float16) -> mat33h +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float16) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33f, b: mat33f, t: float32) -> mat33f +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33d, b: mat33d, t: float64) -> mat33d +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float64) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat33, b: mat33, t: float32) -> mat33 +.. function:: lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44h, b: mat44h, t: float16) -> mat44h +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float16) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44f, b: mat44f, t: float32) -> mat44f +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44d, b: mat44d, t: float64) -> mat44d +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float64) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: mat44, b: mat44, t: float32) -> mat44 +.. function:: lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quath, b: quath, t: float16) -> quath +.. function:: lerp(a: quaternion[], b: quaternion[], t: float16) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quatf, b: quatf, t: float32) -> quatf +.. function:: lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quatd, b: quatd, t: float64) -> quatd +.. function:: lerp(a: quaternion[], b: quaternion[], t: float64) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: quat, b: quat, t: float32) -> quat +.. function:: lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformh, b: transformh, t: float16) -> transformh +.. function:: lerp(a: transform_t[], b: transform_t[], t: float16) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformf, b: transformf, t: float32) -> transformf +.. function:: lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transformd, b: transformd, t: float64) -> transformd +.. function:: lerp(a: transform_t[], b: transform_t[], t: float64) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: transform, b: transform, t: float32) -> transform +.. function:: lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectorh, b: spatial_vectorh, t: float16) -> spatial_vectorh +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float16) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectorf, b: spatial_vectorf, t: float32) -> spatial_vectorf +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vectord, b: spatial_vectord, t: float64) -> spatial_vectord +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float64) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_vector, b: spatial_vector, t: float32) -> spatial_vector +.. function:: lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixh, b: spatial_matrixh, t: float16) -> spatial_matrixh +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float16) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixf, b: spatial_matrixf, t: float32) -> spatial_matrixf +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrixd, b: spatial_matrixd, t: float64) -> spatial_matrixd +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float64) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: lerp(a: spatial_matrix, b: spatial_matrix, t: float32) -> spatial_matrix +.. function:: lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[] Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` -.. function:: smoothstep(edge0: float16, edge1: float16, x: float16) -> float16 +.. function:: smoothstep(edge0: float64, edge1: float64, x: float64) -> float64 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 -.. function:: smoothstep(edge0: float64, edge1: float64, x: float64) -> float64 +.. function:: smoothstep(edge0: float32, edge1: float32, x: float32) -> float32 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 -.. function:: smoothstep(edge0: float32, edge1: float32, x: float32) -> float32 +.. function:: smoothstep(edge0: float16, edge1: float16, x: float16) -> float16 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 @@ -4565,17 +4565,17 @@ Utility 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 -.. function:: expect_near(arg1: float16, arg2: float16, tolerance: float16) -> None +.. function:: expect_near(arg1: float64, arg2: float64, tolerance: float64) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: float64, arg2: float64, tolerance: float64) -> None +.. function:: expect_near(arg1: float32, arg2: float32, tolerance: float32) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: float32, arg2: float32, tolerance: float32) -> None +.. function:: expect_near(arg1: float16, arg2: float16, tolerance: float16) -> None Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude @@ -4585,7 +4585,7 @@ Utility Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude -.. function:: expect_near(arg1: vec3, arg2: vec3, tolerance: float32) -> None +.. function:: expect_near(arg1: vec[3, ], arg2: vec[3, ], tolerance: float32) -> None Prints an error to stdout if any element of arg1 and arg2 are not closer than tolerance in magnitude @@ -4594,7 +4594,7 @@ Utility Geometry --------------- -.. function:: bvh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> bvh_query_t +.. function:: bvh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4604,7 +4604,7 @@ Geometry :param upper: The upper bound of the bounding box in bvh space -.. function:: bvh_query_ray(id: uint64, start: vec3, dir: vec3) -> bvh_query_t +.. function:: bvh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4620,7 +4620,7 @@ Geometry if there are no more overlapping bound. -.. function:: mesh_query_point(id: uint64, point: vec3, max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool +.. function:: mesh_query_point(id: uint64, point: vec[3, ], max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool Computes the closest point on the mesh with identifier `id` to the given point in space. Returns ``True`` if a point < ``max_dist`` is found. @@ -4633,7 +4633,7 @@ Geometry :param bary_v: Retruns the barycentric v coordinate of the closest point -.. function:: mesh_query_ray(id: uint64, start: vec3, dir: vec3, max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec3, face: int32) -> bool +.. function:: mesh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ], max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec[3, ], face: int32) -> bool Computes the closest ray hit on the mesh with identifier `id`, returns ``True`` if a point < ``max_t`` is found. @@ -4649,7 +4649,7 @@ Geometry :param face: Returns the index of the hit face -.. function:: mesh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> mesh_query_aabb_t +.. function:: mesh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> mesh_query_aabb_t Construct an axis-aligned bounding box query against a mesh object. This query can be used to iterate over all triangles inside a volume. Returns an object that is used to track state during mesh traversal. @@ -4665,17 +4665,17 @@ Geometry if there are no more overlapping triangles. -.. function:: mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3 +.. function:: mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ] Evaluates the position on the mesh given a face index, and barycentric coordinates. -.. function:: mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3 +.. function:: mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ] Evaluates the velocity on the mesh given a face index, and barycentric coordinates. -.. function:: hash_grid_query(id: uint64, point: vec3, max_dist: float32) -> hash_grid_query_t +.. function:: hash_grid_query(id: uint64, point: vec[3, ], max_dist: float32) -> hash_grid_query_t Construct a point query against a hash grid. This query can be used to iterate over all neighboring points withing a fixed radius from the query point. Returns an object that is used to track state during neighbor traversal. @@ -4693,7 +4693,7 @@ Geometry traversal occurs in a spatially coherent order. -.. function:: intersect_tri_tri(v0: vec3, v1: vec3, v2: vec3, u0: vec3, u1: vec3, u2: vec3) -> int +.. function:: intersect_tri_tri(v0: vec[3, ], v1: vec[3, ], v2: vec[3, ], u0: vec[3, ], u1: vec[3, ], u2: vec[3, ]) -> int Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method. Returns > 0 if triangles intersect. @@ -4703,17 +4703,17 @@ Geometry Retrieves the mesh given its index. -.. function:: mesh_eval_face_normal(id: uint64, face: int32) -> vec3 +.. function:: mesh_eval_face_normal(id: uint64, face: int32) -> vec[3, ] Evaluates the face normal the mesh given a face index. -.. function:: mesh_get_point(id: uint64, index: int32) -> vec3 +.. function:: mesh_get_point(id: uint64, index: int32) -> vec[3, ] Returns the point of the mesh given a index. -.. function:: mesh_get_velocity(id: uint64, index: int32) -> vec3 +.. function:: mesh_get_velocity(id: uint64, index: int32) -> vec[3, ] Returns the velocity of the mesh given a index. @@ -4723,7 +4723,7 @@ Geometry Returns the point-index of the mesh given a face-vertex index. -.. function:: closest_point_edge_edge(p1: vec3, q1: vec3, p2: vec3, q2: vec3, epsilon: float32) -> vec3 +.. function:: closest_point_edge_edge(p1: vec[3, ], q1: vec[3, ], p2: vec[3, ], q2: vec[3, ], epsilon: float32) -> vec[3, ] 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. @@ -4739,7 +4739,7 @@ Geometry Volumes --------------- -.. function:: volume_sample_f(id: uint64, uvw: vec3, sampling_mode: int32) -> float +.. function:: volume_sample_f(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> float Sample the volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` @@ -4754,22 +4754,22 @@ Volumes Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_sample_v(id: uint64, uvw: vec3, sampling_mode: int32) -> vec3 +.. function:: volume_sample_v(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> vec[3, ] Sample the vector volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` -.. function:: volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec3 +.. function:: volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec[3, ] 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 -.. function:: volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3) -> None +.. function:: volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec[3, ]) -> None Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_sample_i(id: uint64, uvw: vec3) -> int +.. function:: volume_sample_i(id: uint64, uvw: vec[3, ]) -> int Sample the int32 volume given by ``id`` at the volume local-space point ``uvw``. @@ -4784,22 +4784,22 @@ Volumes Store the value at voxel with coordinates ``i``, ``j``, ``k``. -.. function:: volume_index_to_world(id: uint64, uvw: vec3) -> vec3 +.. function:: volume_index_to_world(id: uint64, uvw: vec[3, ]) -> vec[3, ] Transform a point defined in volume index space to world space given the volume's intrinsic affine transformation. -.. function:: volume_world_to_index(id: uint64, xyz: vec3) -> vec3 +.. function:: volume_world_to_index(id: uint64, xyz: vec[3, ]) -> vec[3, ] Transform a point defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. -.. function:: volume_index_to_world_dir(id: uint64, uvw: vec3) -> vec3 +.. function:: volume_index_to_world_dir(id: uint64, uvw: vec[3, ]) -> vec[3, ] Transform a direction defined in volume index space to world space given the volume's intrinsic affine transformation. -.. function:: volume_world_to_index_dir(id: uint64, xyz: vec3) -> vec3 +.. function:: volume_world_to_index_dir(id: uint64, xyz: vec[3, ]) -> vec[3, ] Transform a direction defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. @@ -4850,47 +4850,47 @@ Random Inverse transform sample a cumulative distribution function -.. function:: sample_triangle(state: uint32) -> vec2 +.. function:: sample_triangle(state: uint32) -> vec[2, ] Uniformly sample a triangle. Returns sample barycentric coordinates -.. function:: sample_unit_ring(state: uint32) -> vec2 +.. function:: sample_unit_ring(state: uint32) -> vec[2, ] Uniformly sample a ring in the xy plane -.. function:: sample_unit_disk(state: uint32) -> vec2 +.. function:: sample_unit_disk(state: uint32) -> vec[2, ] Uniformly sample a disk in the xy plane -.. function:: sample_unit_sphere_surface(state: uint32) -> vec3 +.. function:: sample_unit_sphere_surface(state: uint32) -> vec[3, ] Uniformly sample a unit sphere surface -.. function:: sample_unit_sphere(state: uint32) -> vec3 +.. function:: sample_unit_sphere(state: uint32) -> vec[3, ] Uniformly sample a unit sphere -.. function:: sample_unit_hemisphere_surface(state: uint32) -> vec3 +.. function:: sample_unit_hemisphere_surface(state: uint32) -> vec[3, ] Uniformly sample a unit hemisphere surface -.. function:: sample_unit_hemisphere(state: uint32) -> vec3 +.. function:: sample_unit_hemisphere(state: uint32) -> vec[3, ] Uniformly sample a unit hemisphere -.. function:: sample_unit_square(state: uint32) -> vec2 +.. function:: sample_unit_square(state: uint32) -> vec[2, ] Uniformly sample a unit square -.. function:: sample_unit_cube(state: uint32) -> vec3 +.. function:: sample_unit_cube(state: uint32) -> vec[3, ] Uniformly sample a unit cube @@ -4900,17 +4900,17 @@ Random Non-periodic Perlin-style noise in 1d. -.. function:: noise(state: uint32, xy: vec2) -> float +.. function:: noise(state: uint32, xy: vec[2, ]) -> float Non-periodic Perlin-style noise in 2d. -.. function:: noise(state: uint32, xyz: vec3) -> float +.. function:: noise(state: uint32, xyz: vec[3, ]) -> float Non-periodic Perlin-style noise in 3d. -.. function:: noise(state: uint32, xyzt: vec4) -> float +.. function:: noise(state: uint32, xyzt: vec[4, ]) -> float Non-periodic Perlin-style noise in 4d. @@ -4920,32 +4920,32 @@ Random Periodic Perlin-style noise in 1d. -.. function:: pnoise(state: uint32, xy: vec2, px: int32, py: int32) -> float +.. function:: pnoise(state: uint32, xy: vec[2, ], px: int32, py: int32) -> float Periodic Perlin-style noise in 2d. -.. function:: pnoise(state: uint32, xyz: vec3, px: int32, py: int32, pz: int32) -> float +.. function:: pnoise(state: uint32, xyz: vec[3, ], px: int32, py: int32, pz: int32) -> float Periodic Perlin-style noise in 3d. -.. function:: pnoise(state: uint32, xyzt: vec4, px: int32, py: int32, pz: int32, pt: int32) -> float +.. function:: pnoise(state: uint32, xyzt: vec[4, ], px: int32, py: int32, pz: int32, pt: int32) -> float Periodic Perlin-style noise in 4d. -.. function:: curlnoise(state: uint32, xy: vec2) -> vec2 +.. function:: curlnoise(state: uint32, xy: vec[2, ]) -> vec[2, ] Divergence-free vector field based on the gradient of a Perlin noise function. [1]_ -.. function:: curlnoise(state: uint32, xyz: vec3) -> vec3 +.. function:: curlnoise(state: uint32, xyz: vec[3, ]) -> vec[3, ] Divergence-free vector field based on the curl of three Perlin noise functions. [1]_ -.. function:: curlnoise(state: uint32, xyzt: vec4) -> vec3 +.. function:: curlnoise(state: uint32, xyzt: vec[4, ]) -> vec[3, ] Divergence-free vector field based on the curl of three Perlin noise functions. [1]_ @@ -4954,12 +4954,12 @@ Random Other --------------- -.. function:: lower_bound(arr: array[Scalar], value: int32) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int8) -> int +.. function:: lower_bound(arr: array[Scalar], value: int16) -> int Search a sorted array for the closest element greater than or equal to value. @@ -4969,42 +4969,42 @@ Other Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int16) -> int +.. function:: lower_bound(arr: array[Scalar], value: int8) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint32) -> int +.. function:: lower_bound(arr: array[Scalar], value: float16) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: float16) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint16) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint64) -> int +.. function:: lower_bound(arr: array[Scalar], value: int32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint16) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint64) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: int64) -> int +.. function:: lower_bound(arr: array[Scalar], value: float32) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: uint8) -> int +.. function:: lower_bound(arr: array[Scalar], value: int64) -> int Search a sorted array for the closest element greater than or equal to value. -.. function:: lower_bound(arr: array[Scalar], value: float32) -> int +.. function:: lower_bound(arr: array[Scalar], value: uint8) -> int Search a sorted array for the closest element greater than or equal to value. @@ -5018,28 +5018,31 @@ Other Operators --------------- -.. function:: add(x: int32, y: int32) -> int32 +.. function:: add(x: uint32, y: uint32) -> uint32 -.. function:: add(x: int8, y: int8) -> int8 +.. function:: add(x: int16, y: int16) -> int16 .. function:: add(x: float64, y: float64) -> float64 -.. function:: add(x: int16, y: int16) -> int16 +.. function:: add(x: int8, y: int8) -> int8 -.. function:: add(x: uint32, y: uint32) -> uint32 +.. function:: add(x: float16, y: float16) -> float16 -.. function:: add(x: float16, y: float16) -> float16 +.. function:: add(x: uint16, y: uint16) -> uint16 + + +.. function:: add(x: int32, y: int32) -> int32 .. function:: add(x: uint64, y: uint64) -> uint64 -.. function:: add(x: uint16, y: uint16) -> uint16 +.. function:: add(x: float32, y: float32) -> float32 .. function:: add(x: int64, y: int64) -> int64 @@ -5048,241 +5051,241 @@ Operators .. function:: add(x: uint8, y: uint8) -> uint8 -.. function:: add(x: float32, y: float32) -> float32 - - .. function:: add(x: Scalar, y: Scalar) -> Scalar -.. function:: add(x: vec2h, y: vec2h) -> vec2h +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3h, y: vec3h) -> vec3h +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4h, y: vec4h) -> vec4h +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec2d, y: vec2d) -> vec2d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3d, y: vec3d) -> vec3d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec4d, y: vec4d) -> vec4d +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2f, y: vec2f) -> vec2f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2f, y: vec2) -> vec2f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec2, y: vec2f) -> vec2f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec2, y: vec2) -> vec2f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3f, y: vec3f) -> vec3f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3f, y: vec3) -> vec3f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec3, y: vec3f) -> vec3f +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec3, y: vec3) -> vec3f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4f, y: vec4f) -> vec4f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vec4f, y: vec4) -> vec4f +.. function:: add(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: add(x: vec4, y: vec4f) -> vec4f +.. function:: add(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: add(x: vec4, y: vec4) -> vec4f +.. function:: add(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: add(x: quath, y: quath) -> quath +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatd, y: quatd) -> quatd +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatf, y: quatf) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quatf, y: quat) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quat, y: quatf) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: quat, y: quat) -> quatf +.. function:: add(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: add(x: mat22h, y: mat22h) -> mat22h +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat33h, y: mat33h) -> mat33h +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat44h, y: mat44h) -> mat44h +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat22d, y: mat22d) -> mat22d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat33d, y: mat33d) -> mat33d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat44d, y: mat44d) -> mat44d +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat22f, y: mat22f) -> mat22f +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat22f, y: mat22) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat22, y: mat22f) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat22, y: mat22) -> mat22f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat33f, y: mat33f) -> mat33f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat33f, y: mat33) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat33, y: mat33f) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat33, y: mat33) -> mat33f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat44f, y: mat44f) -> mat44f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: mat44f, y: mat44) -> mat44f +.. function:: add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: add(x: mat44, y: mat44f) -> mat44f +.. function:: add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: add(x: mat44, y: mat44) -> mat44f +.. function:: add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: add(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: add(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: add(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: spatial_vector, y: spatial_vector) -> spatial_vectorf +.. function:: add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: add(x: vector_t, y: vector_t) -> vector_t +.. function:: add(x: spatial_vector_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: add(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: add(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: add(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: add(x: transformh, y: transformh) -> transformh +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformd, y: transformd) -> transformd +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformf, y: transformf) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transformf, y: transform) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform, y: transformf) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform, y: transform) -> transformf +.. function:: add(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: add(x: transform_class, y: transform_class) -> transform_class +.. function:: add(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: sub(x: int32, y: int32) -> int32 +.. function:: sub(x: uint32, y: uint32) -> uint32 -.. function:: sub(x: int8, y: int8) -> int8 +.. function:: sub(x: int16, y: int16) -> int16 .. function:: sub(x: float64, y: float64) -> float64 -.. function:: sub(x: int16, y: int16) -> int16 +.. function:: sub(x: int8, y: int8) -> int8 -.. function:: sub(x: uint32, y: uint32) -> uint32 +.. function:: sub(x: float16, y: float16) -> float16 -.. function:: sub(x: float16, y: float16) -> float16 +.. function:: sub(x: uint16, y: uint16) -> uint16 + + +.. function:: sub(x: int32, y: int32) -> int32 .. function:: sub(x: uint64, y: uint64) -> uint64 -.. function:: sub(x: uint16, y: uint16) -> uint16 +.. function:: sub(x: float32, y: float32) -> float32 .. function:: sub(x: int64, y: int64) -> int64 @@ -5291,241 +5294,241 @@ Operators .. function:: sub(x: uint8, y: uint8) -> uint8 -.. function:: sub(x: float32, y: float32) -> float32 - - .. function:: sub(x: Scalar, y: Scalar) -> Scalar -.. function:: sub(x: vec2h, y: vec2h) -> vec2h +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3h, y: vec3h) -> vec3h +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4h, y: vec4h) -> vec4h +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec2d, y: vec2d) -> vec2d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3d, y: vec3d) -> vec3d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec4d, y: vec4d) -> vec4d +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec2ub, y: vec2ub) -> vec2ub +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3ub, y: vec3ub) -> vec3ub +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4ub, y: vec4ub) -> vec4ub +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2f, y: vec2f) -> vec2f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2f, y: vec2) -> vec2f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec2, y: vec2f) -> vec2f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec2, y: vec2) -> vec2f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3f, y: vec3f) -> vec3f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3f, y: vec3) -> vec3f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec3, y: vec3f) -> vec3f +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec3, y: vec3) -> vec3f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4f, y: vec4f) -> vec4f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vec4f, y: vec4) -> vec4f +.. function:: sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ] -.. function:: sub(x: vec4, y: vec4f) -> vec4f +.. function:: sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ] -.. function:: sub(x: vec4, y: vec4) -> vec4f +.. function:: sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: vec[typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: sub(x: mat22h, y: mat22h) -> mat22h +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat33h, y: mat33h) -> mat33h +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat44h, y: mat44h) -> mat44h +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat22d, y: mat22d) -> mat22d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat33d, y: mat33d) -> mat33d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat44d, y: mat44d) -> mat44d +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat22f, y: mat22f) -> mat22f +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat22f, y: mat22) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat22, y: mat22f) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat22, y: mat22) -> mat22f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat33f, y: mat33f) -> mat33f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat33f, y: mat33) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat33, y: mat33f) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat33, y: mat33) -> mat33f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat44f, y: mat44f) -> mat44f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: mat44f, y: mat44) -> mat44f +.. function:: sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: sub(x: mat44, y: mat44f) -> mat44f +.. function:: sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: sub(x: mat44, y: mat44) -> mat44f +.. function:: sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: sub(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: sub(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: sub(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: spatial_vector, y: spatial_vector) -> spatial_vectorf +.. function:: sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: spatial_vector_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: sub(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: sub(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: sub(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: sub(x: quath, y: quath) -> quath +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatd, y: quatd) -> quatd +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatf, y: quatf) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quatf, y: quat) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quat, y: quatf) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: quat, y: quat) -> quatf +.. function:: sub(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: sub(x: vector_t, y: vector_t) -> vector_t +.. function:: sub(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: sub(x: transformh, y: transformh) -> transformh +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformd, y: transformd) -> transformd +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformf, y: transformf) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transformf, y: transform) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform, y: transformf) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform, y: transform) -> transformf +.. function:: sub(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: sub(x: transform_class, y: transform_class) -> transform_class +.. function:: sub(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: int32, y: int32) -> int32 +.. function:: mul(x: uint32, y: uint32) -> uint32 -.. function:: mul(x: int8, y: int8) -> int8 +.. function:: mul(x: int16, y: int16) -> int16 .. function:: mul(x: float64, y: float64) -> float64 -.. function:: mul(x: int16, y: int16) -> int16 +.. function:: mul(x: int8, y: int8) -> int8 -.. function:: mul(x: uint32, y: uint32) -> uint32 +.. function:: mul(x: float16, y: float16) -> float16 -.. function:: mul(x: float16, y: float16) -> float16 +.. function:: mul(x: uint16, y: uint16) -> uint16 + + +.. function:: mul(x: int32, y: int32) -> int32 .. function:: mul(x: uint64, y: uint64) -> uint64 -.. function:: mul(x: uint16, y: uint16) -> uint16 +.. function:: mul(x: float32, y: float32) -> float32 .. function:: mul(x: int64, y: int64) -> int64 @@ -5534,526 +5537,526 @@ Operators .. function:: mul(x: uint8, y: uint8) -> uint8 -.. function:: mul(x: float32, y: float32) -> float32 - - .. function:: mul(x: Scalar, y: Scalar) -> Scalar -.. function:: mul(x: vec2h, y: float16) -> vec2h +.. function:: mul(x: vec[2, ], y: float64) -> vec[2, ] -.. function:: mul(x: vec3h, y: float16) -> vec3h +.. function:: mul(x: vec[3, ], y: float64) -> vec[3, ] -.. function:: mul(x: vec4h, y: float16) -> vec4h +.. function:: mul(x: vec[4, ], y: float64) -> vec[4, ] -.. function:: mul(x: vec2d, y: float64) -> vec2d +.. function:: mul(x: vec[2, ], y: float16) -> vec[2, ] -.. function:: mul(x: vec3d, y: float64) -> vec3d +.. function:: mul(x: vec[3, ], y: float16) -> vec[3, ] -.. function:: mul(x: vec4d, y: float64) -> vec4d +.. function:: mul(x: vec[4, ], y: float16) -> vec[4, ] -.. function:: mul(x: vec2ub, y: uint8) -> vec2ub +.. function:: mul(x: vec[2, ], y: uint8) -> vec[2, ] -.. function:: mul(x: vec3ub, y: uint8) -> vec3ub +.. function:: mul(x: vec[3, ], y: uint8) -> vec[3, ] -.. function:: mul(x: vec4ub, y: uint8) -> vec4ub +.. function:: mul(x: vec[4, ], y: uint8) -> vec[4, ] -.. function:: mul(x: vec2f, y: float32) -> vec2f +.. function:: mul(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: mul(x: vec2, y: float32) -> vec2f +.. function:: mul(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: mul(x: vec3f, y: float32) -> vec3f +.. function:: mul(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: mul(x: vec3, y: float32) -> vec3f +.. function:: mul(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: mul(x: vec4f, y: float32) -> vec4f +.. function:: mul(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: mul(x: vec4, y: float32) -> vec4f +.. function:: mul(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: vec[typing.Any, ~Scalar], y: Scalar) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: float16, y: vec2h) -> vec2h +.. function:: mul(x: float64, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float16, y: vec3h) -> vec3h +.. function:: mul(x: float64, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float16, y: vec4h) -> vec4h +.. function:: mul(x: float64, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float64, y: vec2d) -> vec2d +.. function:: mul(x: float16, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float64, y: vec3d) -> vec3d +.. function:: mul(x: float16, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float64, y: vec4d) -> vec4d +.. function:: mul(x: float16, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: uint8, y: vec2ub) -> vec2ub +.. function:: mul(x: uint8, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: uint8, y: vec3ub) -> vec3ub +.. function:: mul(x: uint8, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: uint8, y: vec4ub) -> vec4ub +.. function:: mul(x: uint8, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float32, y: vec2f) -> vec2f +.. function:: mul(x: float32, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float32, y: vec2) -> vec2f +.. function:: mul(x: float32, y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: float32, y: vec3f) -> vec3f +.. function:: mul(x: float32, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float32, y: vec3) -> vec3f +.. function:: mul(x: float32, y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: float32, y: vec4f) -> vec4f +.. function:: mul(x: float32, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: float32, y: vec4) -> vec4f +.. function:: mul(x: float32, y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: quath, y: float16) -> quath +.. function:: mul(x: quaternion[], y: float64) -> quaternion[] -.. function:: mul(x: quatd, y: float64) -> quatd +.. function:: mul(x: quaternion[], y: float16) -> quaternion[] -.. function:: mul(x: quatf, y: float32) -> quatf +.. function:: mul(x: quaternion[], y: float32) -> quaternion[] -.. function:: mul(x: quat, y: float32) -> quatf +.. function:: mul(x: quaternion[], y: float32) -> quaternion[] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: quaternion[~Scalar], y: Scalar) -> quaternion[~Scalar] -.. function:: mul(x: float16, y: quath) -> quath +.. function:: mul(x: float64, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float64, y: quatd) -> quatd +.. function:: mul(x: float16, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float32, y: quatf) -> quatf +.. function:: mul(x: float32, y: quaternion[]) -> quaternion[] -.. function:: mul(x: float32, y: quat) -> quatf +.. function:: mul(x: float32, y: quaternion[]) -> quaternion[] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: mul(x: quath, y: quath) -> quath +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatd, y: quatd) -> quatd +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatf, y: quatf) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quatf, y: quat) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quat, y: quatf) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: quat, y: quat) -> quatf +.. function:: mul(x: quaternion[], y: quaternion[]) -> quaternion[] -.. function:: mul(x: vector_t, y: vector_t) -> vector_t +.. function:: mul(x: quaternion[~Scalar], y: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: mul(x: float16, y: mat22h) -> mat22h +.. function:: mul(x: float64, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float16, y: mat33h) -> mat33h +.. function:: mul(x: float64, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float16, y: mat44h) -> mat44h +.. function:: mul(x: float64, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float64, y: mat22d) -> mat22d +.. function:: mul(x: float16, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float64, y: mat33d) -> mat33d +.. function:: mul(x: float16, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float64, y: mat44d) -> mat44d +.. function:: mul(x: float16, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float32, y: mat22f) -> mat22f +.. function:: mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float32, y: mat22) -> mat22f +.. function:: mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: float32, y: mat33f) -> mat33f +.. function:: mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float32, y: mat33) -> mat33f +.. function:: mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: float32, y: mat44f) -> mat44f +.. function:: mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: float32, y: mat44) -> mat44f +.. function:: mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: Scalar, y: matrix_t) -> matrix_t +.. function:: mul(x: Scalar, y: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: float16) -> mat22h +.. function:: mul(x: mat[2, 2, ], y: float64) -> mat[2, 2, ] -.. function:: mul(x: mat33h, y: float16) -> mat33h +.. function:: mul(x: mat[3, 3, ], y: float64) -> mat[3, 3, ] -.. function:: mul(x: mat44h, y: float16) -> mat44h +.. function:: mul(x: mat[4, 4, ], y: float64) -> mat[4, 4, ] -.. function:: mul(x: mat22d, y: float64) -> mat22d +.. function:: mul(x: mat[2, 2, ], y: float16) -> mat[2, 2, ] -.. function:: mul(x: mat33d, y: float64) -> mat33d +.. function:: mul(x: mat[3, 3, ], y: float16) -> mat[3, 3, ] -.. function:: mul(x: mat44d, y: float64) -> mat44d +.. function:: mul(x: mat[4, 4, ], y: float16) -> mat[4, 4, ] -.. function:: mul(x: mat22f, y: float32) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: mul(x: mat22, y: float32) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: mul(x: mat33f, y: float32) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: mul(x: mat33, y: float32) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: mul(x: mat44f, y: float32) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: mul(x: mat44, y: float32) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: mul(x: matrix_t, y: Scalar) -> matrix_t +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: vec2h) -> vec2h +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33h, y: vec3h) -> vec3h +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44h, y: vec4h) -> vec4h +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat22d, y: vec2d) -> vec2d +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33d, y: vec3d) -> vec3d +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44d, y: vec4d) -> vec4d +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat22f, y: vec2f) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22f, y: vec2) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22, y: vec2f) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat22, y: vec2) -> vec2f +.. function:: mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ] -.. function:: mul(x: mat33f, y: vec3f) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33f, y: vec3) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33, y: vec3f) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat33, y: vec3) -> vec3f +.. function:: mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ] -.. function:: mul(x: mat44f, y: vec4f) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44f, y: vec4) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44, y: vec4f) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: mat44, y: vec4) -> vec4f +.. function:: mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ] -.. function:: mul(x: matrix_t, y: vector_t) -> vector_t +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: mul(x: mat22h, y: mat22h) -> mat22h +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat33h, y: mat33h) -> mat33h +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat44h, y: mat44h) -> mat44h +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat22d, y: mat22d) -> mat22d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat33d, y: mat33d) -> mat33d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat44d, y: mat44d) -> mat44d +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat22f, y: mat22f) -> mat22f +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat22f, y: mat22) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat22, y: mat22f) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat22, y: mat22) -> mat22f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat33f, y: mat33f) -> mat33f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat33f, y: mat33) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat33, y: mat33f) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat33, y: mat33) -> mat33f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat44f, y: mat44f) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: mat44f, y: mat44) -> mat44f +.. function:: mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: mul(x: mat44, y: mat44f) -> mat44f +.. function:: mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: mul(x: mat44, y: mat44) -> mat44f +.. function:: mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: mul(x: matrix_t, y: matrix_t) +.. function:: mul(x: mat[typing.Any, typing.Any, ~Scalar], y: mat[typing.Any, typing.Any, ~Scalar]) -.. function:: mul(x: spatial_vectorh, y: float16) -> spatial_vectorh +.. function:: mul(x: spatial_vector_t[], y: float64) -> spatial_vector_t[] -.. function:: mul(x: spatial_vectord, y: float64) -> spatial_vectord +.. function:: mul(x: spatial_vector_t[], y: float16) -> spatial_vector_t[] -.. function:: mul(x: spatial_vectorf, y: float32) -> spatial_vectorf +.. function:: mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[] -.. function:: mul(x: spatial_vector, y: float32) -> spatial_vectorf +.. function:: mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[] -.. function:: mul(x: vector_t, y: Scalar) -> vector_t +.. function:: mul(x: spatial_vector_t[~Scalar], y: Scalar) -> spatial_vector_t[~Scalar] -.. function:: mul(x: float16, y: spatial_vectorh) -> spatial_vectorh +.. function:: mul(x: float64, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float64, y: spatial_vectord) -> spatial_vectord +.. function:: mul(x: float16, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float32, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: float32, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: Scalar, y: vector_t) -> vector_t +.. function:: mul(x: Scalar, y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: matrix_t, y: matrix_t) -> matrix_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: spatial_vectorh) -> spatial_vectorh +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixd, y: spatial_vectord) -> spatial_vectord +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrixf, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrix, y: spatial_vectorf) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: spatial_matrix, y: spatial_vector) -> spatial_vectorf +.. function:: mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[] -.. function:: mul(x: matrix_t, y: vector_t) -> vector_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: spatial_vector_t[~Scalar]) -> spatial_vector_t[~Scalar] -.. function:: mul(x: spatial_matrixh, y: float16) -> spatial_matrixh +.. function:: mul(x: spatial_matrix_t[], y: float64) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixd, y: float64) -> spatial_matrixd +.. function:: mul(x: spatial_matrix_t[], y: float16) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrixf, y: float32) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[] -.. function:: mul(x: spatial_matrix, y: float32) -> spatial_matrixf +.. function:: mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[] -.. function:: mul(x: matrix_t, y: Scalar) -> matrix_t +.. function:: mul(x: spatial_matrix_t[~Scalar], y: Scalar) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: float16, y: spatial_matrixh) -> spatial_matrixh +.. function:: mul(x: float64, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float64, y: spatial_matrixd) -> spatial_matrixd +.. function:: mul(x: float16, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float32, y: spatial_matrixf) -> spatial_matrixf +.. function:: mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: float32, y: spatial_matrix) -> spatial_matrixf +.. function:: mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[] -.. function:: mul(x: Scalar, y: matrix_t) -> matrix_t +.. function:: mul(x: Scalar, y: spatial_matrix_t[~Scalar]) -> spatial_matrix_t[~Scalar] -.. function:: mul(x: transformh, y: transformh) -> transformh +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformd, y: transformd) -> transformd +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformf, y: transformf) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transformf, y: transform) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform, y: transformf) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform, y: transform) -> transformf +.. function:: mul(x: transform_t[], y: transform_t[]) -> transform_t[] -.. function:: mul(x: transform_class, y: transform_class) -> transform_class +.. function:: mul(x: transform_t[~Scalar], y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: float16, y: transformh) -> transformh +.. function:: mul(x: float64, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float64, y: transformd) -> transformd +.. function:: mul(x: float16, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float32, y: transformf) -> transformf +.. function:: mul(x: float32, y: transform_t[]) -> transform_t[] -.. function:: mul(x: float32, y: transform) -> transformf +.. function:: mul(x: float32, y: transform_t[]) -> transform_t[] -.. function:: mul(x: Scalar, y: transform_class) -> transform_class +.. function:: mul(x: Scalar, y: transform_t[~Scalar]) -> transform_t[~Scalar] -.. function:: mul(x: transformh, y: float16) -> transformh +.. function:: mul(x: transform_t[], y: float64) -> transform_t[] -.. function:: mul(x: transformd, y: float64) -> transformd +.. function:: mul(x: transform_t[], y: float16) -> transform_t[] -.. function:: mul(x: transformf, y: float32) -> transformf +.. function:: mul(x: transform_t[], y: float32) -> transform_t[] -.. function:: mul(x: transform, y: float32) -> transformf +.. function:: mul(x: transform_t[], y: float32) -> transform_t[] -.. function:: mul(x: transform_class, y: Scalar) -> transform_class +.. function:: mul(x: transform_t[~Scalar], y: Scalar) -> transform_t[~Scalar] -.. function:: mod(x: int32, y: int32) -> int32 +.. function:: mod(x: uint32, y: uint32) -> uint32 -.. function:: mod(x: int8, y: int8) -> int8 +.. function:: mod(x: int16, y: int16) -> int16 .. function:: mod(x: float64, y: float64) -> float64 -.. function:: mod(x: int16, y: int16) -> int16 +.. function:: mod(x: int8, y: int8) -> int8 -.. function:: mod(x: uint32, y: uint32) -> uint32 +.. function:: mod(x: float16, y: float16) -> float16 -.. function:: mod(x: float16, y: float16) -> float16 +.. function:: mod(x: uint16, y: uint16) -> uint16 + + +.. function:: mod(x: int32, y: int32) -> int32 .. function:: mod(x: uint64, y: uint64) -> uint64 -.. function:: mod(x: uint16, y: uint16) -> uint16 +.. function:: mod(x: float32, y: float32) -> float32 .. function:: mod(x: int64, y: int64) -> int64 @@ -6062,34 +6065,34 @@ Operators .. function:: mod(x: uint8, y: uint8) -> uint8 -.. function:: mod(x: float32, y: float32) -> float32 - - .. function:: mod(x: Scalar, y: Scalar) -> Scalar -.. function:: div(x: int32, y: int32) -> int32 +.. function:: div(x: uint32, y: uint32) -> uint32 -.. function:: div(x: int8, y: int8) -> int8 +.. function:: div(x: int16, y: int16) -> int16 .. function:: div(x: float64, y: float64) -> float64 -.. function:: div(x: int16, y: int16) -> int16 +.. function:: div(x: int8, y: int8) -> int8 -.. function:: div(x: uint32, y: uint32) -> uint32 +.. function:: div(x: float16, y: float16) -> float16 -.. function:: div(x: float16, y: float16) -> float16 +.. function:: div(x: uint16, y: uint16) -> uint16 + + +.. function:: div(x: int32, y: int32) -> int32 .. function:: div(x: uint64, y: uint64) -> uint64 -.. function:: div(x: uint16, y: uint16) -> uint16 +.. function:: div(x: float32, y: float32) -> float32 .. function:: div(x: int64, y: int64) -> int64 @@ -6098,136 +6101,136 @@ Operators .. function:: div(x: uint8, y: uint8) -> uint8 -.. function:: div(x: float32, y: float32) -> float32 - - .. function:: div(x: Scalar, y: Scalar) -> Scalar -.. function:: div(x: vec2h, y: float16) -> vec2h +.. function:: div(x: vec[2, ], y: float64) -> vec[2, ] -.. function:: div(x: vec3h, y: float16) -> vec3h +.. function:: div(x: vec[3, ], y: float64) -> vec[3, ] -.. function:: div(x: vec4h, y: float16) -> vec4h +.. function:: div(x: vec[4, ], y: float64) -> vec[4, ] -.. function:: div(x: vec2d, y: float64) -> vec2d +.. function:: div(x: vec[2, ], y: float16) -> vec[2, ] -.. function:: div(x: vec3d, y: float64) -> vec3d +.. function:: div(x: vec[3, ], y: float16) -> vec[3, ] -.. function:: div(x: vec4d, y: float64) -> vec4d +.. function:: div(x: vec[4, ], y: float16) -> vec[4, ] -.. function:: div(x: vec2ub, y: uint8) -> vec2ub +.. function:: div(x: vec[2, ], y: uint8) -> vec[2, ] -.. function:: div(x: vec3ub, y: uint8) -> vec3ub +.. function:: div(x: vec[3, ], y: uint8) -> vec[3, ] -.. function:: div(x: vec4ub, y: uint8) -> vec4ub +.. function:: div(x: vec[4, ], y: uint8) -> vec[4, ] -.. function:: div(x: vec2f, y: float32) -> vec2f +.. function:: div(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: div(x: vec2, y: float32) -> vec2f +.. function:: div(x: vec[2, ], y: float32) -> vec[2, ] -.. function:: div(x: vec3f, y: float32) -> vec3f +.. function:: div(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: div(x: vec3, y: float32) -> vec3f +.. function:: div(x: vec[3, ], y: float32) -> vec[3, ] -.. function:: div(x: vec4f, y: float32) -> vec4f +.. function:: div(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: div(x: vec4, y: float32) -> vec4f +.. function:: div(x: vec[4, ], y: float32) -> vec[4, ] -.. function:: div(x: vector_t, y: Scalar) -> vector_t +.. function:: div(x: vec[typing.Any, ~Scalar], y: Scalar) -> vec[typing.Any, ~Scalar] -.. function:: div(x: mat22h, y: float16) -> mat22h +.. function:: div(x: mat[2, 2, ], y: float64) -> mat[2, 2, ] -.. function:: div(x: mat33h, y: float16) -> mat33h +.. function:: div(x: mat[3, 3, ], y: float64) -> mat[3, 3, ] -.. function:: div(x: mat44h, y: float16) -> mat44h +.. function:: div(x: mat[4, 4, ], y: float64) -> mat[4, 4, ] -.. function:: div(x: mat22d, y: float64) -> mat22d +.. function:: div(x: mat[2, 2, ], y: float16) -> mat[2, 2, ] -.. function:: div(x: mat33d, y: float64) -> mat33d +.. function:: div(x: mat[3, 3, ], y: float16) -> mat[3, 3, ] -.. function:: div(x: mat44d, y: float64) -> mat44d +.. function:: div(x: mat[4, 4, ], y: float16) -> mat[4, 4, ] -.. function:: div(x: mat22f, y: float32) -> mat22f +.. function:: div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: div(x: mat22, y: float32) -> mat22f +.. function:: div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ] -.. function:: div(x: mat33f, y: float32) -> mat33f +.. function:: div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: div(x: mat33, y: float32) -> mat33f +.. function:: div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ] -.. function:: div(x: mat44f, y: float32) -> mat44f +.. function:: div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: div(x: mat44, y: float32) -> mat44f +.. function:: div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ] -.. function:: div(x: matrix_t, y: Scalar) -> matrix_t +.. function:: div(x: mat[typing.Any, typing.Any, ~Scalar], y: Scalar) -> mat[typing.Any, typing.Any, ~Scalar] -.. function:: div(x: quath, y: float16) -> quath +.. function:: div(x: quaternion[], y: float64) -> quaternion[] -.. function:: div(x: quatd, y: float64) -> quatd +.. function:: div(x: quaternion[], y: float16) -> quaternion[] -.. function:: div(x: quatf, y: float32) -> quatf +.. function:: div(x: quaternion[], y: float32) -> quaternion[] -.. function:: div(x: quat, y: float32) -> quatf +.. function:: div(x: quaternion[], y: float32) -> quaternion[] -.. function:: div(x: vector_t, y: Scalar) -> vector_t +.. function:: div(x: quaternion[~Scalar], y: Scalar) -> quaternion[~Scalar] -.. function:: floordiv(x: int32, y: int32) -> int32 +.. function:: floordiv(x: uint32, y: uint32) -> uint32 -.. function:: floordiv(x: int8, y: int8) -> int8 +.. function:: floordiv(x: int16, y: int16) -> int16 .. function:: floordiv(x: float64, y: float64) -> float64 -.. function:: floordiv(x: int16, y: int16) -> int16 +.. function:: floordiv(x: int8, y: int8) -> int8 -.. function:: floordiv(x: uint32, y: uint32) -> uint32 +.. function:: floordiv(x: float16, y: float16) -> float16 -.. function:: floordiv(x: float16, y: float16) -> float16 +.. function:: floordiv(x: uint16, y: uint16) -> uint16 + + +.. function:: floordiv(x: int32, y: int32) -> int32 .. function:: floordiv(x: uint64, y: uint64) -> uint64 -.. function:: floordiv(x: uint16, y: uint16) -> uint16 +.. function:: floordiv(x: float32, y: float32) -> float32 .. function:: floordiv(x: int64, y: int64) -> int64 @@ -6236,34 +6239,34 @@ Operators .. function:: floordiv(x: uint8, y: uint8) -> uint8 -.. function:: floordiv(x: float32, y: float32) -> float32 - - .. function:: floordiv(x: Scalar, y: Scalar) -> Scalar -.. function:: neg(x: int32) -> int32 +.. function:: neg(x: uint32) -> uint32 -.. function:: neg(x: int8) -> int8 +.. function:: neg(x: int16) -> int16 .. function:: neg(x: float64) -> float64 -.. function:: neg(x: int16) -> int16 +.. function:: neg(x: int8) -> int8 -.. function:: neg(x: uint32) -> uint32 +.. function:: neg(x: float16) -> float16 -.. function:: neg(x: float16) -> float16 +.. function:: neg(x: uint16) -> uint16 + + +.. function:: neg(x: int32) -> int32 .. function:: neg(x: uint64) -> uint64 -.. function:: neg(x: uint16) -> uint16 +.. function:: neg(x: float32) -> float32 .. function:: neg(x: int64) -> int64 @@ -6272,112 +6275,109 @@ Operators .. function:: neg(x: uint8) -> uint8 -.. function:: neg(x: float32) -> float32 - - .. function:: neg(x: Scalar) -> Scalar -.. function:: neg(x: vec2h) -> vec2h +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec3h) -> vec3h +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec4h) -> vec4h +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec2d) -> vec2d +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec3d) -> vec3d +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec4d) -> vec4d +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec2ub) -> vec2ub +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec3ub) -> vec3ub +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec4ub) -> vec4ub +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec2f) -> vec2f +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec2) -> vec2f +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec3f) -> vec3f +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vec3) -> vec3f +.. function:: neg(x: vec[2, ]) -> vec[2, ] -.. function:: neg(x: vec4f) -> vec4f +.. function:: neg(x: vec[3, ]) -> vec[3, ] -.. function:: neg(x: vec4) -> vec4f +.. function:: neg(x: vec[4, ]) -> vec[4, ] -.. function:: neg(x: vector_t) -> vector_t +.. function:: neg(x: vec[typing.Any, ~Scalar]) -> vec[typing.Any, ~Scalar] -.. function:: neg(x: quath) -> quath +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quatd) -> quatd +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quatf) -> quatf +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: quat) -> quatf +.. function:: neg(x: quaternion[]) -> quaternion[] -.. function:: neg(x: vector_t) -> vector_t +.. function:: neg(x: quaternion[~Scalar]) -> quaternion[~Scalar] -.. function:: neg(x: mat22h) -> mat22h +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat33h) -> mat33h +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat44h) -> mat44h +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat22d) -> mat22d +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat33d) -> mat33d +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat44d) -> mat44d +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat22f) -> mat22f +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat22) -> mat22f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat33f) -> mat33f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: mat33) -> mat33f +.. function:: neg(x: mat[2, 2, ]) -> mat[2, 2, ] -.. function:: neg(x: mat44f) -> mat44f +.. function:: neg(x: mat[3, 3, ]) -> mat[3, 3, ] -.. function:: neg(x: mat44) -> mat44f +.. function:: neg(x: mat[4, 4, ]) -> mat[4, 4, ] -.. function:: neg(x: matrix_t) -> matrix_t +.. function:: neg(x: mat[typing.Any, typing.Any, ~Scalar]) -> mat[typing.Any, typing.Any, ~Scalar] .. function:: unot(b: bool) -> bool diff --git a/exts/omni.warp/config/extension.toml b/exts/omni.warp/config/extension.toml index 11d384d89..23b9b3e5e 100644 --- a/exts/omni.warp/config/extension.toml +++ b/exts/omni.warp/config/extension.toml @@ -1,7 +1,7 @@ [package] # Semantic Versioning is used: https://semver.org/ -version = "0.7.1" +version = "0.7.2" authors = ["NVIDIA"] title = "Warp" description="A Python framework for high-performance simulation and graphics programming" diff --git a/exts/omni.warp/docs/CHANGELOG.md b/exts/omni.warp/docs/CHANGELOG.md index ef57684af..513d5c7b6 100644 --- a/exts/omni.warp/docs/CHANGELOG.md +++ b/exts/omni.warp/docs/CHANGELOG.md @@ -1,5 +1,12 @@ # CHANGELOG +## [0.7.2] - 2023-02-15 + +- Reduce test time for vec/math types +- Clean-up CUDA disabled build pipeline +- Remove extension.gen.toml to make Kit packages Python version independent +- Handle additional cases for array indexing inside Python + ## [0.7.1] - 2023-02-14 - Disabling some slow tests for Kit diff --git a/setup.py b/setup.py index 639207f52..bff75f887 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ setuptools.setup( name="warp-lang", - version="0.7.1", + version="0.7.2", author="NVIDIA", author_email="mmacklin@nvidia.com", description="A Python framework for high-performance simulation and graphics programming", diff --git a/warp/config.py b/warp/config.py index fa6595674..b4bb182a9 100644 --- a/warp/config.py +++ b/warp/config.py @@ -7,7 +7,7 @@ import os -version = "0.7.1" +version = "0.7.2" cuda_path = None # path to local CUDA toolchain, if None at init time warp will attempt to find the SDK using CUDA_PATH env var diff --git a/warp/stubs.py b/warp/stubs.py index e7558094f..538ed2de8 100644 --- a/warp/stubs.py +++ b/warp/stubs.py @@ -56,14 +56,14 @@ @overload -def min(x: int32, y: int32) -> int32: +def min(x: uint32, y: uint32) -> uint32: """ Return the minimum of two scalars. """ ... @overload -def min(x: int8, y: int8) -> int8: +def min(x: int16, y: int16) -> int16: """ Return the minimum of two scalars. """ @@ -77,217 +77,217 @@ def min(x: float64, y: float64) -> float64: ... @overload -def min(x: int16, y: int16) -> int16: +def min(x: int8, y: int8) -> int8: """ Return the minimum of two scalars. """ ... @overload -def min(x: uint32, y: uint32) -> uint32: +def min(x: float16, y: float16) -> float16: """ Return the minimum of two scalars. """ ... @overload -def min(x: float16, y: float16) -> float16: +def min(x: uint16, y: uint16) -> uint16: """ Return the minimum of two scalars. """ ... @overload -def min(x: uint64, y: uint64) -> uint64: +def min(x: int32, y: int32) -> int32: """ Return the minimum of two scalars. """ ... @overload -def min(x: uint16, y: uint16) -> uint16: +def min(x: uint64, y: uint64) -> uint64: """ Return the minimum of two scalars. """ ... @overload -def min(x: int64, y: int64) -> int64: +def min(x: float32, y: float32) -> float32: """ Return the minimum of two scalars. """ ... @overload -def min(x: uint8, y: uint8) -> uint8: +def min(x: int64, y: int64) -> int64: """ Return the minimum of two scalars. """ ... @overload -def min(x: float32, y: float32) -> float32: +def min(x: uint8, y: uint8) -> uint8: """ Return the minimum of two scalars. """ ... @overload -def min(x: vec2h, y: vec2h) -> vec2h: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3h, y: vec3h) -> vec3h: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4h, y: vec4h) -> vec4h: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2d, y: vec2d) -> vec2d: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3d, y: vec3d) -> vec3d: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4d, y: vec4d) -> vec4d: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2ub, y: vec2ub) -> vec2ub: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3ub, y: vec3ub) -> vec3ub: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4ub, y: vec4ub) -> vec4ub: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2f, y: vec2f) -> vec2f: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2f, y: vec2) -> vec2f: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2, y: vec2f) -> vec2f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec2, y: vec2) -> vec2f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3f, y: vec3f) -> vec3f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3f, y: vec3) -> vec3f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3, y: vec3f) -> vec3f: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec3, y: vec3) -> vec3f: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4f, y: vec4f) -> vec4f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4f, y: vec4) -> vec4f: +def min(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4, y: vec4f) -> vec4f: +def min(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def min(x: vec4, y: vec4) -> vec4f: +def min(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise minimum of two vectors. """ ... @overload -def max(x: int32, y: int32) -> int32: +def max(x: uint32, y: uint32) -> uint32: """ Return the maximum of two scalars. """ ... @overload -def max(x: int8, y: int8) -> int8: +def max(x: int16, y: int16) -> int16: """ Return the maximum of two scalars. """ @@ -301,217 +301,217 @@ def max(x: float64, y: float64) -> float64: ... @overload -def max(x: int16, y: int16) -> int16: +def max(x: int8, y: int8) -> int8: """ Return the maximum of two scalars. """ ... @overload -def max(x: uint32, y: uint32) -> uint32: +def max(x: float16, y: float16) -> float16: """ Return the maximum of two scalars. """ ... @overload -def max(x: float16, y: float16) -> float16: +def max(x: uint16, y: uint16) -> uint16: """ Return the maximum of two scalars. """ ... @overload -def max(x: uint64, y: uint64) -> uint64: +def max(x: int32, y: int32) -> int32: """ Return the maximum of two scalars. """ ... @overload -def max(x: uint16, y: uint16) -> uint16: +def max(x: uint64, y: uint64) -> uint64: """ Return the maximum of two scalars. """ ... @overload -def max(x: int64, y: int64) -> int64: +def max(x: float32, y: float32) -> float32: """ Return the maximum of two scalars. """ ... @overload -def max(x: uint8, y: uint8) -> uint8: +def max(x: int64, y: int64) -> int64: """ Return the maximum of two scalars. """ ... @overload -def max(x: float32, y: float32) -> float32: +def max(x: uint8, y: uint8) -> uint8: """ Return the maximum of two scalars. """ ... @overload -def max(x: vec2h, y: vec2h) -> vec2h: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3h, y: vec3h) -> vec3h: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4h, y: vec4h) -> vec4h: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2d, y: vec2d) -> vec2d: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3d, y: vec3d) -> vec3d: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4d, y: vec4d) -> vec4d: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2ub, y: vec2ub) -> vec2ub: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3ub, y: vec3ub) -> vec3ub: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4ub, y: vec4ub) -> vec4ub: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2f, y: vec2f) -> vec2f: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2f, y: vec2) -> vec2f: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2, y: vec2f) -> vec2f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec2, y: vec2) -> vec2f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3f, y: vec3f) -> vec3f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3f, y: vec3) -> vec3f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3, y: vec3f) -> vec3f: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec3, y: vec3) -> vec3f: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4f, y: vec4f) -> vec4f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4f, y: vec4) -> vec4f: +def max(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4, y: vec4f) -> vec4f: +def max(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def max(x: vec4, y: vec4) -> vec4f: +def max(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Return the element wise maximum of two vectors. """ ... @overload -def clamp(x: int32, a: int32, b: int32) -> int32: +def clamp(x: uint32, a: uint32, b: uint32) -> uint32: """ Clamp the value of x to the range [a, b]. """ ... @overload -def clamp(x: int8, a: int8, b: int8) -> int8: +def clamp(x: int16, a: int16, b: int16) -> int16: """ Clamp the value of x to the range [a, b]. """ @@ -525,21 +525,28 @@ def clamp(x: float64, a: float64, b: float64) -> float64: ... @overload -def clamp(x: int16, a: int16, b: int16) -> int16: +def clamp(x: int8, a: int8, b: int8) -> int8: """ Clamp the value of x to the range [a, b]. """ ... @overload -def clamp(x: uint32, a: uint32, b: uint32) -> uint32: +def clamp(x: float16, a: float16, b: float16) -> float16: """ Clamp the value of x to the range [a, b]. """ ... @overload -def clamp(x: float16, a: float16, b: float16) -> float16: +def clamp(x: uint16, a: uint16, b: uint16) -> uint16: + """ + Clamp the value of x to the range [a, b]. + """ + ... + +@overload +def clamp(x: int32, a: int32, b: int32) -> int32: """ Clamp the value of x to the range [a, b]. """ @@ -553,7 +560,7 @@ def clamp(x: uint64, a: uint64, b: uint64) -> uint64: ... @overload -def clamp(x: uint16, a: uint16, b: uint16) -> uint16: +def clamp(x: float32, a: float32, b: float32) -> float32: """ Clamp the value of x to the range [a, b]. """ @@ -574,49 +581,49 @@ def clamp(x: uint8, a: uint8, b: uint8) -> uint8: ... @overload -def clamp(x: float32, a: float32, b: float32) -> float32: +def abs(x: uint32) -> uint32: """ - Clamp the value of x to the range [a, b]. + Return the absolute value of x. """ ... @overload -def abs(x: int32) -> int32: +def abs(x: int16) -> int16: """ Return the absolute value of x. """ ... @overload -def abs(x: int8) -> int8: +def abs(x: float64) -> float64: """ Return the absolute value of x. """ ... @overload -def abs(x: float64) -> float64: +def abs(x: int8) -> int8: """ Return the absolute value of x. """ ... @overload -def abs(x: int16) -> int16: +def abs(x: float16) -> float16: """ Return the absolute value of x. """ ... @overload -def abs(x: uint32) -> uint32: +def abs(x: uint16) -> uint16: """ Return the absolute value of x. """ ... @overload -def abs(x: float16) -> float16: +def abs(x: int32) -> int32: """ Return the absolute value of x. """ @@ -630,7 +637,7 @@ def abs(x: uint64) -> uint64: ... @overload -def abs(x: uint16) -> uint16: +def abs(x: float32) -> float32: """ Return the absolute value of x. """ @@ -651,49 +658,49 @@ def abs(x: uint8) -> uint8: ... @overload -def abs(x: float32) -> float32: +def sign(x: uint32) -> uint32: """ - Return the absolute value of x. + Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: int32) -> int32: +def sign(x: int16) -> int16: """ Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: int8) -> int8: +def sign(x: float64) -> float64: """ Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: float64) -> float64: +def sign(x: int8) -> int8: """ Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: int16) -> int16: +def sign(x: float16) -> float16: """ Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: uint32) -> uint32: +def sign(x: uint16) -> uint16: """ Return -1 if x < 0, return 1 otherwise. """ ... @overload -def sign(x: float16) -> float16: +def sign(x: int32) -> int32: """ Return -1 if x < 0, return 1 otherwise. """ @@ -707,7 +714,7 @@ def sign(x: uint64) -> uint64: ... @overload -def sign(x: uint16) -> uint16: +def sign(x: float32) -> float32: """ Return -1 if x < 0, return 1 otherwise. """ @@ -728,49 +735,49 @@ def sign(x: uint8) -> uint8: ... @overload -def sign(x: float32) -> float32: +def step(x: uint32) -> uint32: """ - Return -1 if x < 0, return 1 otherwise. + Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: int32) -> int32: +def step(x: int16) -> int16: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: int8) -> int8: +def step(x: float64) -> float64: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: float64) -> float64: +def step(x: int8) -> int8: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: int16) -> int16: +def step(x: float16) -> float16: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: uint32) -> uint32: +def step(x: uint16) -> uint16: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ ... @overload -def step(x: float16) -> float16: +def step(x: int32) -> int32: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ @@ -784,7 +791,7 @@ def step(x: uint64) -> uint64: ... @overload -def step(x: uint16) -> uint16: +def step(x: float32) -> float32: """ Return 1.0 if x < 0.0, return 0.0 otherwise. """ @@ -805,49 +812,49 @@ def step(x: uint8) -> uint8: ... @overload -def step(x: float32) -> float32: +def nonzero(x: uint32) -> uint32: """ - Return 1.0 if x < 0.0, return 0.0 otherwise. + Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: int32) -> int32: +def nonzero(x: int16) -> int16: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: int8) -> int8: +def nonzero(x: float64) -> float64: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: float64) -> float64: +def nonzero(x: int8) -> int8: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: int16) -> int16: +def nonzero(x: float16) -> float16: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: uint32) -> uint32: +def nonzero(x: uint16) -> uint16: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ ... @overload -def nonzero(x: float16) -> float16: +def nonzero(x: int32) -> int32: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ @@ -861,7 +868,7 @@ def nonzero(x: uint64) -> uint64: ... @overload -def nonzero(x: uint16) -> uint16: +def nonzero(x: float32) -> float32: """ Return 1.0 if x is not equal to zero, return 0.0 otherwise. """ @@ -881,20 +888,6 @@ def nonzero(x: uint8) -> uint8: """ ... -@overload -def nonzero(x: float32) -> float32: - """ - Return 1.0 if x is not equal to zero, return 0.0 otherwise. - """ - ... - -@overload -def sin(x: float16) -> float16: - """ - Return the sine of x in radians. - """ - ... - @overload def sin(x: float64) -> float64: """ @@ -910,9 +903,9 @@ def sin(x: float32) -> float32: ... @overload -def cos(x: float16) -> float16: +def sin(x: float16) -> float16: """ - Return the cosine of x in radians. + Return the sine of x in radians. """ ... @@ -931,9 +924,9 @@ def cos(x: float32) -> float32: ... @overload -def acos(x: float16) -> float16: +def cos(x: float16) -> float16: """ - Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. + Return the cosine of x in radians. """ ... @@ -952,9 +945,9 @@ def acos(x: float32) -> float32: ... @overload -def asin(x: float16) -> float16: +def acos(x: float16) -> float16: """ - Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. + Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. """ ... @@ -973,9 +966,9 @@ def asin(x: float32) -> float32: ... @overload -def sqrt(x: float16) -> float16: +def asin(x: float16) -> float16: """ - Return the sqrt of x, where x is positive. + Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0]. """ ... @@ -994,9 +987,9 @@ def sqrt(x: float32) -> float32: ... @overload -def tan(x: float16) -> float16: +def sqrt(x: float16) -> float16: """ - Return tangent of x in radians. + Return the sqrt of x, where x is positive. """ ... @@ -1015,9 +1008,9 @@ def tan(x: float32) -> float32: ... @overload -def atan(x: float16) -> float16: +def tan(x: float16) -> float16: """ - Return arctan of x. + Return tangent of x in radians. """ ... @@ -1036,9 +1029,9 @@ def atan(x: float32) -> float32: ... @overload -def atan2(y: float16, x: float16) -> float16: +def atan(x: float16) -> float16: """ - Return atan2 of x. + Return arctan of x. """ ... @@ -1057,9 +1050,9 @@ def atan2(y: float32, x: float32) -> float32: ... @overload -def sinh(x: float16) -> float16: +def atan2(y: float16, x: float16) -> float16: """ - Return the sinh of x. + Return atan2 of x. """ ... @@ -1078,9 +1071,9 @@ def sinh(x: float32) -> float32: ... @overload -def cosh(x: float16) -> float16: +def sinh(x: float16) -> float16: """ - Return the cosh of x. + Return the sinh of x. """ ... @@ -1099,9 +1092,9 @@ def cosh(x: float32) -> float32: ... @overload -def tanh(x: float16) -> float16: +def cosh(x: float16) -> float16: """ - Return the tanh of x. + Return the cosh of x. """ ... @@ -1120,23 +1113,23 @@ def tanh(x: float32) -> float32: ... @overload -def degrees(x: float32) -> float: +def tanh(x: float16) -> float16: """ - Convert radians into degrees. + Return the tanh of x. """ ... @overload -def radians(x: float32) -> float: +def degrees(x: float32) -> float: """ - Convert degrees into radians. + Convert radians into degrees. """ ... @overload -def log(x: float16) -> float16: +def radians(x: float32) -> float: """ - Return the natural log (base-e) of x, where x is positive. + Convert degrees into radians. """ ... @@ -1155,9 +1148,9 @@ def log(x: float32) -> float32: ... @overload -def log2(x: float16) -> float16: +def log(x: float16) -> float16: """ - Return the natural log (base-2) of x, where x is positive. + Return the natural log (base-e) of x, where x is positive. """ ... @@ -1176,9 +1169,9 @@ def log2(x: float32) -> float32: ... @overload -def log10(x: float16) -> float16: +def log2(x: float16) -> float16: """ - Return the natural log (base-10) of x, where x is positive. + Return the natural log (base-2) of x, where x is positive. """ ... @@ -1197,9 +1190,9 @@ def log10(x: float32) -> float32: ... @overload -def exp(x: float16) -> float16: +def log10(x: float16) -> float16: """ - Return base-e exponential, e^x. + Return the natural log (base-10) of x, where x is positive. """ ... @@ -1218,9 +1211,9 @@ def exp(x: float32) -> float32: ... @overload -def pow(x: float16, y: float16) -> float16: +def exp(x: float16) -> float16: """ - Return the result of x raised to power of y. + Return base-e exponential, e^x. """ ... @@ -1239,7 +1232,14 @@ def pow(x: float32, y: float32) -> float32: ... @overload -def round(x: float16) -> float16: +def pow(x: float16, y: float16) -> float16: + """ + Return the result of x raised to power of y. + """ + ... + +@overload +def round(x: float64) -> float64: """ Calculate the nearest integer value, 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()``. @@ -1248,7 +1248,7 @@ def round(x: float16) -> float16: ... @overload -def round(x: float64) -> float64: +def round(x: float32) -> float32: """ Calculate the nearest integer value, 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()``. @@ -1257,7 +1257,7 @@ def round(x: float64) -> float64: ... @overload -def round(x: float32) -> float32: +def round(x: float16) -> float16: """ Calculate the nearest integer value, 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()``. @@ -1266,7 +1266,7 @@ def round(x: float32) -> float32: ... @overload -def rint(x: float16) -> float16: +def rint(x: float64) -> float64: """ Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. @@ -1275,7 +1275,7 @@ def rint(x: float16) -> float16: ... @overload -def rint(x: float64) -> float64: +def rint(x: float32) -> float32: """ Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. @@ -1284,7 +1284,7 @@ def rint(x: float64) -> float64: ... @overload -def rint(x: float32) -> float32: +def rint(x: float16) -> float16: """ Calculate the nearest integer value, rounding halfway cases to nearest even integer. It is generally faster than ``warp.round()``. @@ -1293,7 +1293,7 @@ def rint(x: float32) -> float32: ... @overload -def trunc(x: float16) -> float16: +def trunc(x: float64) -> float64: """ Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1303,7 +1303,7 @@ def trunc(x: float16) -> float16: ... @overload -def trunc(x: float64) -> float64: +def trunc(x: float32) -> float32: """ Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1313,7 +1313,7 @@ def trunc(x: float64) -> float64: ... @overload -def trunc(x: float32) -> float32: +def trunc(x: float16) -> float16: """ Calculate the nearest integer that is closer to zero than x. In other words, it discards the fractional part of x. @@ -1323,1960 +1323,1960 @@ def trunc(x: float32) -> float32: ... @overload -def floor(x: float16) -> float16: +def floor(x: float64) -> float64: """ Calculate the largest integer that is less than or equal to x. """ ... @overload -def floor(x: float64) -> float64: +def floor(x: float32) -> float32: """ Calculate the largest integer that is less than or equal to x. """ ... @overload -def floor(x: float32) -> float32: +def floor(x: float16) -> float16: """ Calculate the largest integer that is less than or equal to x. """ ... @overload -def ceil(x: float16) -> float16: +def ceil(x: float64) -> float64: """ Calculate the smallest integer that is greater than or equal to x. """ ... @overload -def ceil(x: float64) -> float64: +def ceil(x: float32) -> float32: """ Calculate the smallest integer that is greater than or equal to x. """ ... @overload -def ceil(x: float32) -> float32: +def ceil(x: float16) -> float16: """ Calculate the smallest integer that is greater than or equal to x. """ ... @overload -def dot(x: vec2h, y: vec2h) -> float16: +def dot(x: vec[2, ], y: vec[2, ]) -> float64: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3h, y: vec3h) -> float16: +def dot(x: vec[3, ], y: vec[3, ]) -> float64: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4h, y: vec4h) -> float16: +def dot(x: vec[4, ], y: vec[4, ]) -> float64: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2d, y: vec2d) -> float64: +def dot(x: vec[2, ], y: vec[2, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3d, y: vec3d) -> float64: +def dot(x: vec[2, ], y: vec[2, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4d, y: vec4d) -> float64: +def dot(x: vec[2, ], y: vec[2, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2ub, y: vec2ub) -> uint8: +def dot(x: vec[2, ], y: vec[2, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3ub, y: vec3ub) -> uint8: +def dot(x: vec[3, ], y: vec[3, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4ub, y: vec4ub) -> uint8: +def dot(x: vec[3, ], y: vec[3, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2f, y: vec2f) -> float32: +def dot(x: vec[3, ], y: vec[3, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2f, y: vec2) -> float32: +def dot(x: vec[3, ], y: vec[3, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2, y: vec2f) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec2, y: vec2) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3f, y: vec3f) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3f, y: vec3) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> float32: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3, y: vec3f) -> float32: +def dot(x: vec[2, ], y: vec[2, ]) -> uint8: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec3, y: vec3) -> float32: +def dot(x: vec[3, ], y: vec[3, ]) -> uint8: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4f, y: vec4f) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> uint8: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4f, y: vec4) -> float32: +def dot(x: vec[2, ], y: vec[2, ]) -> float16: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4, y: vec4f) -> float32: +def dot(x: vec[3, ], y: vec[3, ]) -> float16: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: vec4, y: vec4) -> float32: +def dot(x: vec[4, ], y: vec[4, ]) -> float16: """ Compute the dot product between two vectors. """ ... @overload -def dot(x: quath, y: quath) -> float16: +def dot(x: quaternion[], y: quaternion[]) -> float64: """ Compute the dot product between two quaternions. """ ... @overload -def dot(x: quatd, y: quatd) -> float64: +def dot(x: quaternion[], y: quaternion[]) -> float32: """ Compute the dot product between two quaternions. """ ... @overload -def dot(x: quatf, y: quatf) -> float32: +def dot(x: quaternion[], y: quaternion[]) -> float32: """ Compute the dot product between two quaternions. """ ... @overload -def dot(x: quatf, y: quat) -> float32: +def dot(x: quaternion[], y: quaternion[]) -> float32: """ Compute the dot product between two quaternions. """ ... @overload -def dot(x: quat, y: quatf) -> float32: +def dot(x: quaternion[], y: quaternion[]) -> float32: """ Compute the dot product between two quaternions. """ ... @overload -def dot(x: quat, y: quat) -> float32: +def dot(x: quaternion[], y: quaternion[]) -> float16: """ Compute the dot product between two quaternions. """ ... @overload -def ddot(x: mat22h, y: mat22h) -> float16: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float64: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33h, y: mat33h) -> float16: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float64: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44h, y: mat44h) -> float16: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float64: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat22d, y: mat22d) -> float64: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33d, y: mat33d) -> float64: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44d, y: mat44d) -> float64: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat22f, y: mat22f) -> float32: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat22f, y: mat22) -> float32: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat22, y: mat22f) -> float32: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat22, y: mat22) -> float32: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33f, y: mat33f) -> float32: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33f, y: mat33) -> float32: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33, y: mat33f) -> float32: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat33, y: mat33) -> float32: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44f, y: mat44f) -> float32: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float32: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44f, y: mat44) -> float32: +def ddot(x: mat[2, 2, ], y: mat[2, 2, ]) -> float16: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44, y: mat44f) -> float32: +def ddot(x: mat[3, 3, ], y: mat[3, 3, ]) -> float16: """ Compute the double dot product between two matrices. """ ... @overload -def ddot(x: mat44, y: mat44) -> float32: +def ddot(x: mat[4, 4, ], y: mat[4, 4, ]) -> float16: """ Compute the double dot product between two matrices. """ ... @overload -def outer(x: vec2h, y: vec2h) -> mat22h: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3h, y: vec3h) -> mat33h: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4h, y: vec4h) -> mat44h: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec2d, y: vec2d) -> mat22d: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3d, y: vec3d) -> mat33d: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4d, y: vec4d) -> mat44d: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec2f, y: vec2f) -> mat22f: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec2f, y: vec2) -> mat22f: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec2, y: vec2f) -> mat22f: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec2, y: vec2) -> mat22f: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3f, y: vec3f) -> mat33f: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3f, y: vec3) -> mat33f: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3, y: vec3f) -> mat33f: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec3, y: vec3) -> mat33f: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4f, y: vec4f) -> mat44f: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4f, y: vec4) -> mat44f: +def outer(x: vec[2, ], y: vec[2, ]) -> mat[2, 2, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4, y: vec4f) -> mat44f: +def outer(x: vec[3, ], y: vec[3, ]) -> mat[3, 3, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: vec4, y: vec4) -> mat44f: +def outer(x: vec[4, ], y: vec[4, ]) -> mat[4, 4, ]: """ Compute the outer product x*y^T for two vec2 objects. """ ... @overload -def outer(x: spatial_vectorh, y: spatial_vectorh) -> spatial_matrixh: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def outer(x: spatial_vectord, y: spatial_vectord) -> spatial_matrixd: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def outer(x: spatial_vectorf, y: spatial_vectorf) -> spatial_matrixf: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def outer(x: spatial_vectorf, y: spatial_vector) -> spatial_matrixf: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def outer(x: spatial_vector, y: spatial_vectorf) -> spatial_matrixf: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def outer(x: spatial_vector, y: spatial_vector) -> spatial_matrixf: +def outer(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_matrix_t[]: """ Compute the outer product x*y^T for two spatial_vector objects. """ ... @overload -def cross(x: vec3h, y: vec3h) -> vec3h: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3d, y: vec3d) -> vec3d: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3ub, y: vec3ub) -> vec3ub: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3f, y: vec3f) -> vec3f: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3f, y: vec3) -> vec3f: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3, y: vec3f) -> vec3f: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def cross(x: vec3, y: vec3) -> vec3f: +def cross(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Compute the cross product of two 3d vectors. """ ... @overload -def skew(x: vec3h) -> mat33h: +def skew(x: vec[3, ]) -> mat[3, 3, ]: """ Compute the skew symmetric matrix for a 3d vector. """ ... @overload -def skew(x: vec3d) -> mat33d: +def skew(x: vec[3, ]) -> mat[3, 3, ]: """ Compute the skew symmetric matrix for a 3d vector. """ ... @overload -def skew(x: vec3f) -> mat33f: +def skew(x: vec[3, ]) -> mat[3, 3, ]: """ Compute the skew symmetric matrix for a 3d vector. """ ... @overload -def skew(x: vec3) -> mat33f: +def skew(x: vec[3, ]) -> mat[3, 3, ]: """ Compute the skew symmetric matrix for a 3d vector. """ ... @overload -def length(x: vec2h) -> float16: +def length(x: vec[2, ]) -> float64: """ Compute the length of a vector. """ ... @overload -def length(x: vec3h) -> float16: +def length(x: vec[3, ]) -> float64: """ Compute the length of a vector. """ ... @overload -def length(x: vec4h) -> float16: +def length(x: vec[4, ]) -> float64: """ Compute the length of a vector. """ ... @overload -def length(x: vec2d) -> float64: +def length(x: vec[2, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec3d) -> float64: +def length(x: vec[2, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec4d) -> float64: +def length(x: vec[3, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec2f) -> float32: +def length(x: vec[3, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec2) -> float32: +def length(x: vec[4, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec3f) -> float32: +def length(x: vec[4, ]) -> float32: """ Compute the length of a vector. """ ... @overload -def length(x: vec3) -> float32: +def length(x: vec[2, ]) -> float16: """ Compute the length of a vector. """ ... @overload -def length(x: vec4f) -> float32: +def length(x: vec[3, ]) -> float16: """ Compute the length of a vector. """ ... @overload -def length(x: vec4) -> float32: +def length(x: vec[4, ]) -> float16: """ Compute the length of a vector. """ ... @overload -def length(x: quath) -> float16: +def length(x: quaternion[]) -> float64: """ Compute the length of a quaternion. """ ... @overload -def length(x: quatd) -> float64: +def length(x: quaternion[]) -> float32: """ Compute the length of a quaternion. """ ... @overload -def length(x: quatf) -> float32: +def length(x: quaternion[]) -> float32: """ Compute the length of a quaternion. """ ... @overload -def length(x: quat) -> float32: +def length(x: quaternion[]) -> float16: """ Compute the length of a quaternion. """ ... @overload -def length_sq(x: vec2h) -> float16: +def length_sq(x: vec[2, ]) -> float64: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec3h) -> float16: +def length_sq(x: vec[3, ]) -> float64: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec4h) -> float16: +def length_sq(x: vec[4, ]) -> float64: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec2d) -> float64: +def length_sq(x: vec[2, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec3d) -> float64: +def length_sq(x: vec[2, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec4d) -> float64: +def length_sq(x: vec[3, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec2ub) -> uint8: +def length_sq(x: vec[3, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec3ub) -> uint8: +def length_sq(x: vec[4, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec4ub) -> uint8: +def length_sq(x: vec[4, ]) -> float32: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec2f) -> float32: +def length_sq(x: vec[2, ]) -> uint8: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec2) -> float32: +def length_sq(x: vec[3, ]) -> uint8: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec3f) -> float32: +def length_sq(x: vec[4, ]) -> uint8: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec3) -> float32: +def length_sq(x: vec[2, ]) -> float16: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec4f) -> float32: +def length_sq(x: vec[3, ]) -> float16: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: vec4) -> float32: +def length_sq(x: vec[4, ]) -> float16: """ Compute the squared length of a 2d vector. """ ... @overload -def length_sq(x: quath) -> float16: +def length_sq(x: quaternion[]) -> float64: """ Compute the squared length of a quaternion. """ ... @overload -def length_sq(x: quatd) -> float64: +def length_sq(x: quaternion[]) -> float32: """ Compute the squared length of a quaternion. """ ... @overload -def length_sq(x: quatf) -> float32: +def length_sq(x: quaternion[]) -> float32: """ Compute the squared length of a quaternion. """ ... @overload -def length_sq(x: quat) -> float32: +def length_sq(x: quaternion[]) -> float16: """ Compute the squared length of a quaternion. """ ... @overload -def normalize(x: vec2h) -> vec2h: +def normalize(x: vec[2, ]) -> vec[2, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec3h) -> vec3h: +def normalize(x: vec[3, ]) -> vec[3, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec4h) -> vec4h: +def normalize(x: vec[4, ]) -> vec[4, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec2d) -> vec2d: +def normalize(x: vec[2, ]) -> vec[2, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec3d) -> vec3d: +def normalize(x: vec[2, ]) -> vec[2, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec4d) -> vec4d: +def normalize(x: vec[3, ]) -> vec[3, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec2f) -> vec2f: +def normalize(x: vec[3, ]) -> vec[3, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec2) -> vec2f: +def normalize(x: vec[4, ]) -> vec[4, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec3f) -> vec3f: +def normalize(x: vec[4, ]) -> vec[4, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec3) -> vec3f: +def normalize(x: vec[2, ]) -> vec[2, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec4f) -> vec4f: +def normalize(x: vec[3, ]) -> vec[3, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: vec4) -> vec4f: +def normalize(x: vec[4, ]) -> vec[4, ]: """ Compute the normalized value of x, if length(x) is 0 then the zero vector is returned. """ ... @overload -def normalize(x: quath) -> quath: +def normalize(x: quaternion[]) -> quaternion[]: """ Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. """ ... @overload -def normalize(x: quatd) -> quatd: +def normalize(x: quaternion[]) -> quaternion[]: """ Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. """ ... @overload -def normalize(x: quatf) -> quatf: +def normalize(x: quaternion[]) -> quaternion[]: """ Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. """ ... @overload -def normalize(x: quat) -> quatf: +def normalize(x: quaternion[]) -> quaternion[]: """ Compute the normalized value of x, if length(x) is 0 then the zero quat is returned. """ ... @overload -def transpose(m: mat22h) -> mat22h: +def transpose(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat33h) -> mat33h: +def transpose(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat44h) -> mat44h: +def transpose(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat22d) -> mat22d: +def transpose(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat33d) -> mat33d: +def transpose(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat44d) -> mat44d: +def transpose(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat22f) -> mat22f: +def transpose(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat22) -> mat22f: +def transpose(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat33f) -> mat33f: +def transpose(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat33) -> mat33f: +def transpose(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat44f) -> mat44f: +def transpose(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: mat44) -> mat44f: +def transpose(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: spatial_matrixh) -> spatial_matrixh: +def transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: spatial_matrixd) -> spatial_matrixd: +def transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: spatial_matrixf) -> spatial_matrixf: +def transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[]: """ Return the transpose of the matrix m """ ... @overload -def transpose(m: spatial_matrix) -> spatial_matrixf: +def transpose(m: spatial_matrix_t[]) -> spatial_matrix_t[]: """ Return the transpose of the matrix m """ ... @overload -def inverse(m: mat22h) -> mat22h: +def inverse(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat33h) -> mat33h: +def inverse(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat44h) -> mat44h: +def inverse(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat22d) -> mat22d: +def inverse(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat33d) -> mat33d: +def inverse(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat44d) -> mat44d: +def inverse(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat22f) -> mat22f: +def inverse(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat22) -> mat22f: +def inverse(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat33f) -> mat33f: +def inverse(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat33) -> mat33f: +def inverse(m: mat[2, 2, ]) -> mat[2, 2, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat44f) -> mat44f: +def inverse(m: mat[3, 3, ]) -> mat[3, 3, ]: """ Return the inverse of the matrix m """ ... @overload -def inverse(m: mat44) -> mat44f: +def inverse(m: mat[4, 4, ]) -> mat[4, 4, ]: """ Return the inverse of the matrix m """ ... @overload -def determinant(m: mat22h) -> float16: +def determinant(m: mat[2, 2, ]) -> float64: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat33h) -> float16: +def determinant(m: mat[3, 3, ]) -> float64: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat44h) -> float16: +def determinant(m: mat[4, 4, ]) -> float64: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat22d) -> float64: +def determinant(m: mat[2, 2, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat33d) -> float64: +def determinant(m: mat[2, 2, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat44d) -> float64: +def determinant(m: mat[3, 3, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat22f) -> float32: +def determinant(m: mat[3, 3, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat22) -> float32: +def determinant(m: mat[4, 4, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat33f) -> float32: +def determinant(m: mat[4, 4, ]) -> float32: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat33) -> float32: +def determinant(m: mat[2, 2, ]) -> float16: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat44f) -> float32: +def determinant(m: mat[3, 3, ]) -> float16: """ Return the determinant of the matrix m """ ... @overload -def determinant(m: mat44) -> float32: +def determinant(m: mat[4, 4, ]) -> float16: """ Return the determinant of the matrix m """ ... @overload -def trace(m: mat22h) -> float16: +def trace(m: mat[2, 2, ]) -> float64: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat33h) -> float16: +def trace(m: mat[3, 3, ]) -> float64: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat44h) -> float16: +def trace(m: mat[4, 4, ]) -> float64: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat22d) -> float64: +def trace(m: mat[2, 2, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat33d) -> float64: +def trace(m: mat[2, 2, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat44d) -> float64: +def trace(m: mat[3, 3, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat22f) -> float32: +def trace(m: mat[3, 3, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat22) -> float32: +def trace(m: mat[4, 4, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat33f) -> float32: +def trace(m: mat[4, 4, ]) -> float32: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat33) -> float32: +def trace(m: mat[2, 2, ]) -> float16: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat44f) -> float32: +def trace(m: mat[3, 3, ]) -> float16: """ Return the trace of the matrix m """ ... @overload -def trace(m: mat44) -> float32: +def trace(m: mat[4, 4, ]) -> float16: """ Return the trace of the matrix m """ ... @overload -def diag(d: vec2h) -> mat22h: +def diag(d: vec[2, ]) -> mat[2, 2, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec3h) -> mat33h: +def diag(d: vec[3, ]) -> mat[3, 3, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec4h) -> mat44h: +def diag(d: vec[4, ]) -> mat[4, 4, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec2d) -> mat22d: +def diag(d: vec[2, ]) -> mat[2, 2, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec3d) -> mat33d: +def diag(d: vec[2, ]) -> mat[2, 2, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec4d) -> mat44d: +def diag(d: vec[3, ]) -> mat[3, 3, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec2f) -> mat22f: +def diag(d: vec[3, ]) -> mat[3, 3, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec2) -> mat22f: +def diag(d: vec[4, ]) -> mat[4, 4, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec3f) -> mat33f: +def diag(d: vec[4, ]) -> mat[4, 4, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec3) -> mat33f: +def diag(d: vec[2, ]) -> mat[2, 2, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec4f) -> mat44f: +def diag(d: vec[3, ]) -> mat[3, 3, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def diag(d: vec4) -> mat44f: +def diag(d: vec[4, ]) -> mat[4, 4, ]: """ Returns a matrix with the components of the vector d on the diagonal """ ... @overload -def cw_mul(x: vec2h, y: vec2h) -> vec2h: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3h, y: vec3h) -> vec3h: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4h, y: vec4h) -> vec4h: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2d, y: vec2d) -> vec2d: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3d, y: vec3d) -> vec3d: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4d, y: vec4d) -> vec4d: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2ub, y: vec2ub) -> vec2ub: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3ub, y: vec3ub) -> vec3ub: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4ub, y: vec4ub) -> vec4ub: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2f, y: vec2f) -> vec2f: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2f, y: vec2) -> vec2f: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2, y: vec2f) -> vec2f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec2, y: vec2) -> vec2f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3f, y: vec3f) -> vec3f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3f, y: vec3) -> vec3f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3, y: vec3f) -> vec3f: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec3, y: vec3) -> vec3f: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4f, y: vec4f) -> vec4f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4f, y: vec4) -> vec4f: +def cw_mul(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4, y: vec4f) -> vec4f: +def cw_mul(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: vec4, y: vec4) -> vec4f: +def cw_mul(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22h, y: mat22h) -> mat22h: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33h, y: mat33h) -> mat33h: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44h, y: mat44h) -> mat44h: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22d, y: mat22d) -> mat22d: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33d, y: mat33d) -> mat33d: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44d, y: mat44d) -> mat44d: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22f, y: mat22f) -> mat22f: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22f, y: mat22) -> mat22f: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22, y: mat22f) -> mat22f: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat22, y: mat22) -> mat22f: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33f, y: mat33f) -> mat33f: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33f, y: mat33) -> mat33f: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33, y: mat33f) -> mat33f: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat33, y: mat33) -> mat33f: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44f, y: mat44f) -> mat44f: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44f, y: mat44) -> mat44f: +def cw_mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44, y: mat44f) -> mat44f: +def cw_mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_mul(x: mat44, y: mat44) -> mat44f: +def cw_mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise multiply of two 2d vectors. """ ... @overload -def cw_div(x: vec2h, y: vec2h) -> vec2h: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3h, y: vec3h) -> vec3h: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4h, y: vec4h) -> vec4h: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2d, y: vec2d) -> vec2d: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3d, y: vec3d) -> vec3d: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4d, y: vec4d) -> vec4d: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2ub, y: vec2ub) -> vec2ub: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3ub, y: vec3ub) -> vec3ub: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4ub, y: vec4ub) -> vec4ub: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2f, y: vec2f) -> vec2f: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2f, y: vec2) -> vec2f: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2, y: vec2f) -> vec2f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec2, y: vec2) -> vec2f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3f, y: vec3f) -> vec3f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3f, y: vec3) -> vec3f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3, y: vec3f) -> vec3f: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec3, y: vec3) -> vec3f: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4f, y: vec4f) -> vec4f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4f, y: vec4) -> vec4f: +def cw_div(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4, y: vec4f) -> vec4f: +def cw_div(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: vec4, y: vec4) -> vec4f: +def cw_div(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22h, y: mat22h) -> mat22h: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33h, y: mat33h) -> mat33h: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44h, y: mat44h) -> mat44h: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22d, y: mat22d) -> mat22d: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33d, y: mat33d) -> mat33d: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44d, y: mat44d) -> mat44d: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22f, y: mat22f) -> mat22f: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22f, y: mat22) -> mat22f: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22, y: mat22f) -> mat22f: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat22, y: mat22) -> mat22f: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33f, y: mat33f) -> mat33f: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33f, y: mat33) -> mat33f: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33, y: mat33f) -> mat33f: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat33, y: mat33) -> mat33f: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44f, y: mat44f) -> mat44f: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44f, y: mat44) -> mat44f: +def cw_div(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44, y: mat44f) -> mat44f: +def cw_div(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ Component wise division of two 2d vectors. """ ... @overload -def cw_div(x: mat44, y: mat44) -> mat44f: +def cw_div(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ Component wise division of two 2d vectors. """ ... @overload -def svd3(A: mat33h, U: mat33h, sigma: vec3h, V: mat33h): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3284,7 +3284,7 @@ def svd3(A: mat33h, U: mat33h, sigma: vec3h, V: mat33h): ... @overload -def svd3(A: mat33d, U: mat33d, sigma: vec3d, V: mat33d): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3292,7 +3292,7 @@ def svd3(A: mat33d, U: mat33d, sigma: vec3d, V: mat33d): ... @overload -def svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3300,7 +3300,7 @@ def svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33f): ... @overload -def svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3308,7 +3308,7 @@ def svd3(A: mat33f, U: mat33f, sigma: vec3f, V: mat33): ... @overload -def svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3316,7 +3316,7 @@ def svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33f): ... @overload -def svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3324,7 +3324,7 @@ def svd3(A: mat33f, U: mat33f, sigma: vec3, V: mat33): ... @overload -def svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3332,7 +3332,7 @@ def svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33f): ... @overload -def svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3340,7 +3340,7 @@ def svd3(A: mat33f, U: mat33, sigma: vec3f, V: mat33): ... @overload -def svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3348,7 +3348,7 @@ def svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33f): ... @overload -def svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3356,7 +3356,7 @@ def svd3(A: mat33f, U: mat33, sigma: vec3, V: mat33): ... @overload -def svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3364,7 +3364,7 @@ def svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33f): ... @overload -def svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3372,7 +3372,7 @@ def svd3(A: mat33, U: mat33f, sigma: vec3f, V: mat33): ... @overload -def svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3380,7 +3380,7 @@ def svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33f): ... @overload -def svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3388,7 +3388,7 @@ def svd3(A: mat33, U: mat33f, sigma: vec3, V: mat33): ... @overload -def svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3396,7 +3396,7 @@ def svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33f): ... @overload -def svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3404,7 +3404,7 @@ def svd3(A: mat33, U: mat33, sigma: vec3f, V: mat33): ... @overload -def svd3(A: mat33, U: mat33, sigma: vec3, V: mat33f): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3412,7 +3412,7 @@ def svd3(A: mat33, U: mat33, sigma: vec3, V: mat33f): ... @overload -def svd3(A: mat33, U: mat33, sigma: vec3, V: mat33): +def svd3(A: mat[3, 3, ], U: mat[3, 3, ], sigma: vec[3, ], V: mat[3, 3, ]): """ Compute the SVD of a 3x3 matrix. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V. @@ -3420,602 +3420,602 @@ def svd3(A: mat33, U: mat33, sigma: vec3, V: mat33): ... @overload -def qr3(A: mat33h, Q: mat33h, R: mat33h): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33d, Q: mat33d, R: mat33d): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33f, Q: mat33f, R: mat33f): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33f, Q: mat33f, R: mat33): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33f, Q: mat33, R: mat33f): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33f, Q: mat33, R: mat33): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33, Q: mat33f, R: mat33f): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33, Q: mat33f, R: mat33): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33, Q: mat33, R: mat33f): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def qr3(A: mat33, Q: mat33, R: mat33): +def qr3(A: mat[3, 3, ], Q: mat[3, 3, ], R: mat[3, 3, ]): """ Compute the QR decomposition of a 3x3 matrix. The orthogonal matrix is returned in Q, while the upper triangular matrix is returend in R. """ ... @overload -def eig3(A: mat33h, Q: mat33h, d: vec3h): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33d, Q: mat33d, d: vec3d): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33f, Q: mat33f, d: vec3f): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33f, Q: mat33f, d: vec3): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33f, Q: mat33, d: vec3f): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33f, Q: mat33, d: vec3): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33, Q: mat33f, d: vec3f): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33, Q: mat33f, d: vec3): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33, Q: mat33, d: vec3f): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def eig3(A: mat33, Q: mat33, d: vec3): +def eig3(A: mat[3, 3, ], Q: mat[3, 3, ], d: vec[3, ]): """ Compute the eigen decomposition of a 3x3 marix. The eigen vectors are returned as the columns of Q, while the corresponding eigen values are returned in d. """ ... @overload -def quat_identity() -> quat: +def quat_identity() -> quaternion[]: """ Construct a float32 identity quaternion with zero imaginary part and real part of 1.0 """ ... @overload -def quat_from_axis_angle(axis: vec3h, angle: float16) -> quath: +def quat_from_axis_angle(axis: vec[3, ], angle: float64) -> quaternion[]: """ Construct a quaternion representing a rotation of angle radians around the given axis. """ ... @overload -def quat_from_axis_angle(axis: vec3d, angle: float64) -> quatd: +def quat_from_axis_angle(axis: vec[3, ], angle: float16) -> quaternion[]: """ Construct a quaternion representing a rotation of angle radians around the given axis. """ ... @overload -def quat_from_axis_angle(axis: vec3f, angle: float32) -> quatf: +def quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[]: """ Construct a quaternion representing a rotation of angle radians around the given axis. """ ... @overload -def quat_from_axis_angle(axis: vec3, angle: float32) -> quatf: +def quat_from_axis_angle(axis: vec[3, ], angle: float32) -> quaternion[]: """ Construct a quaternion representing a rotation of angle radians around the given axis. """ ... @overload -def quat_to_axis_angle(q: quath, axis: vec3h, angle: float16): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float64): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_to_axis_angle(q: quatd, axis: vec3d, angle: float64): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_to_axis_angle(q: quatf, axis: vec3f, angle: float32): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_to_axis_angle(q: quatf, axis: vec3, angle: float32): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_to_axis_angle(q: quat, axis: vec3f, angle: float32): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float32): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_to_axis_angle(q: quat, axis: vec3, angle: float32): +def quat_to_axis_angle(q: quaternion[], axis: vec[3, ], angle: float16): """ Extract the rotation axis and angle radians a quaternion represents. """ ... @overload -def quat_from_matrix(m: mat33h) -> quath: +def quat_from_matrix(m: mat[3, 3, ]) -> quaternion[]: """ Construct a quaternion from a 3x3 matrix. """ ... @overload -def quat_from_matrix(m: mat33d) -> quatd: +def quat_from_matrix(m: mat[3, 3, ]) -> quaternion[]: """ Construct a quaternion from a 3x3 matrix. """ ... @overload -def quat_from_matrix(m: mat33f) -> quatf: +def quat_from_matrix(m: mat[3, 3, ]) -> quaternion[]: """ Construct a quaternion from a 3x3 matrix. """ ... @overload -def quat_from_matrix(m: mat33) -> quatf: +def quat_from_matrix(m: mat[3, 3, ]) -> quaternion[]: """ Construct a quaternion from a 3x3 matrix. """ ... @overload -def quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quath: +def quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quaternion[]: """ Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. """ ... @overload -def quat_rpy(roll: float64, pitch: float64, yaw: float64) -> quatd: +def quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quaternion[]: """ Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. """ ... @overload -def quat_rpy(roll: float32, pitch: float32, yaw: float32) -> quatf: +def quat_rpy(roll: float16, pitch: float16, yaw: float16) -> quaternion[]: """ Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. """ ... @overload -def quat_inverse(q: quath) -> quath: +def quat_inverse(q: quaternion[]) -> quaternion[]: """ Compute quaternion conjugate. """ ... @overload -def quat_inverse(q: quatd) -> quatd: +def quat_inverse(q: quaternion[]) -> quaternion[]: """ Compute quaternion conjugate. """ ... @overload -def quat_inverse(q: quatf) -> quatf: +def quat_inverse(q: quaternion[]) -> quaternion[]: """ Compute quaternion conjugate. """ ... @overload -def quat_inverse(q: quat) -> quatf: +def quat_inverse(q: quaternion[]) -> quaternion[]: """ Compute quaternion conjugate. """ ... @overload -def quat_rotate(q: quath, p: vec3h) -> vec3h: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate(q: quatd, p: vec3d) -> vec3d: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate(q: quatf, p: vec3f) -> vec3f: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate(q: quatf, p: vec3) -> vec3f: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate(q: quat, p: vec3f) -> vec3f: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate(q: quat, p: vec3) -> vec3f: +def quat_rotate(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector by a quaternion. """ ... @overload -def quat_rotate_inv(q: quath, p: vec3h) -> vec3h: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_rotate_inv(q: quatd, p: vec3d) -> vec3d: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_rotate_inv(q: quatf, p: vec3f) -> vec3f: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_rotate_inv(q: quatf, p: vec3) -> vec3f: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_rotate_inv(q: quat, p: vec3f) -> vec3f: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_rotate_inv(q: quat, p: vec3) -> vec3f: +def quat_rotate_inv(q: quaternion[], p: vec[3, ]) -> vec[3, ]: """ Rotate a vector the inverse of a quaternion. """ ... @overload -def quat_slerp(q0: quath, q1: quath, t: float16) -> quath: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float64) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_slerp(q0: quatd, q1: quatd, t: float64) -> quatd: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float16) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_slerp(q0: quatf, q1: quatf, t: float32) -> quatf: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_slerp(q0: quatf, q1: quat, t: float32) -> quatf: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_slerp(q0: quat, q1: quatf, t: float32) -> quatf: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_slerp(q0: quat, q1: quat, t: float32) -> quatf: +def quat_slerp(q0: quaternion[], q1: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate between two quaternions. """ ... @overload -def quat_to_matrix(q: quath) -> mat33h: +def quat_to_matrix(q: quaternion[]) -> mat[3, 3, ]: """ Convert a quaternion to a 3x3 rotation matrix. """ ... @overload -def quat_to_matrix(q: quatd) -> mat33d: +def quat_to_matrix(q: quaternion[]) -> mat[3, 3, ]: """ Convert a quaternion to a 3x3 rotation matrix. """ ... @overload -def quat_to_matrix(q: quatf) -> mat33f: +def quat_to_matrix(q: quaternion[]) -> mat[3, 3, ]: """ Convert a quaternion to a 3x3 rotation matrix. """ ... @overload -def quat_to_matrix(q: quat) -> mat33f: +def quat_to_matrix(q: quaternion[]) -> mat[3, 3, ]: """ Convert a quaternion to a 3x3 rotation matrix. """ ... @overload -def transform_identity() -> transform: +def transform_identity() -> transform_t[]: """ Construct a float32 identity transform with zero translation and identity rotation. """ ... @overload -def transform_get_translation(t: transformh) -> vec3h: +def transform_get_translation(t: transform_t[]) -> vec[3, ]: """ Return the translational part of a transform. """ ... @overload -def transform_get_translation(t: transformd) -> vec3d: +def transform_get_translation(t: transform_t[]) -> vec[3, ]: """ Return the translational part of a transform. """ ... @overload -def transform_get_translation(t: transformf) -> vec3f: +def transform_get_translation(t: transform_t[]) -> vec[3, ]: """ Return the translational part of a transform. """ ... @overload -def transform_get_translation(t: transform) -> vec3f: +def transform_get_translation(t: transform_t[]) -> vec[3, ]: """ Return the translational part of a transform. """ ... @overload -def transform_get_rotation(t: transformh) -> quath: +def transform_get_rotation(t: transform_t[]) -> quaternion[]: """ Return the rotational part of a transform. """ ... @overload -def transform_get_rotation(t: transformd) -> quatd: +def transform_get_rotation(t: transform_t[]) -> quaternion[]: """ Return the rotational part of a transform. """ ... @overload -def transform_get_rotation(t: transformf) -> quatf: +def transform_get_rotation(t: transform_t[]) -> quaternion[]: """ Return the rotational part of a transform. """ ... @overload -def transform_get_rotation(t: transform) -> quatf: +def transform_get_rotation(t: transform_t[]) -> quaternion[]: """ Return the rotational part of a transform. """ ... @overload -def transform_multiply(a: transformh, b: transformh) -> transformh: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_multiply(a: transformd, b: transformd) -> transformd: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_multiply(a: transformf, b: transformf) -> transformf: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_multiply(a: transformf, b: transform) -> transformf: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_multiply(a: transform, b: transformf) -> transformf: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_multiply(a: transform, b: transform) -> transformf: +def transform_multiply(a: transform_t[], b: transform_t[]) -> transform_t[]: """ Multiply two rigid body transformations together. """ ... @overload -def transform_point(t: transformh, p: vec3h) -> vec3h: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(t: transformd, p: vec3d) -> vec3d: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(t: transformf, p: vec3f) -> vec3f: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(t: transformf, p: vec3) -> vec3f: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(t: transform, p: vec3f) -> vec3f: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(t: transform, p: vec3) -> vec3f: +def transform_point(t: transform_t[], p: vec[3, ]) -> vec[3, ]: """ Apply the transform to a point p treating the homogenous coordinate as w=1 (translation and rotation). """ ... @overload -def transform_point(m: mat44h, p: vec3h) -> vec3h: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4024,7 +4024,7 @@ def transform_point(m: mat44h, p: vec3h) -> vec3h: ... @overload -def transform_point(m: mat44d, p: vec3d) -> vec3d: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4033,7 +4033,7 @@ def transform_point(m: mat44d, p: vec3d) -> vec3d: ... @overload -def transform_point(m: mat44f, p: vec3f) -> vec3f: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4042,7 +4042,7 @@ def transform_point(m: mat44f, p: vec3f) -> vec3f: ... @overload -def transform_point(m: mat44f, p: vec3) -> vec3f: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4051,7 +4051,7 @@ def transform_point(m: mat44f, p: vec3) -> vec3f: ... @overload -def transform_point(m: mat44, p: vec3f) -> vec3f: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4060,7 +4060,7 @@ def transform_point(m: mat44, p: vec3f) -> vec3f: ... @overload -def transform_point(m: mat44, p: vec3) -> vec3f: +def transform_point(m: mat[4, 4, ], p: vec[3, ]) -> vec[3, ]: """ 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 @@ -4069,49 +4069,49 @@ def transform_point(m: mat44, p: vec3) -> vec3f: ... @overload -def transform_vector(t: transformh, v: vec3h) -> vec3h: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(t: transformd, v: vec3d) -> vec3d: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(t: transformf, v: vec3f) -> vec3f: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(t: transformf, v: vec3) -> vec3f: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(t: transform, v: vec3f) -> vec3f: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(t: transform, v: vec3) -> vec3f: +def transform_vector(t: transform_t[], v: vec[3, ]) -> vec[3, ]: """ Apply the transform to a vector v treating the homogenous coordinate as w=0 (rotation only). """ ... @overload -def transform_vector(m: mat44h, v: vec3h) -> vec3h: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4120,7 +4120,7 @@ def transform_vector(m: mat44h, v: vec3h) -> vec3h: ... @overload -def transform_vector(m: mat44d, v: vec3d) -> vec3d: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4129,7 +4129,7 @@ def transform_vector(m: mat44d, v: vec3d) -> vec3d: ... @overload -def transform_vector(m: mat44f, v: vec3f) -> vec3f: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4138,7 +4138,7 @@ def transform_vector(m: mat44f, v: vec3f) -> vec3f: ... @overload -def transform_vector(m: mat44f, v: vec3) -> vec3f: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4147,7 +4147,7 @@ def transform_vector(m: mat44f, v: vec3) -> vec3f: ... @overload -def transform_vector(m: mat44, v: vec3f) -> vec3f: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4156,7 +4156,7 @@ def transform_vector(m: mat44, v: vec3f) -> vec3f: ... @overload -def transform_vector(m: mat44, v: vec3) -> vec3f: +def transform_vector(m: mat[4, 4, ], v: vec[3, ]) -> vec[3, ]: """ 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 @@ -4165,224 +4165,224 @@ def transform_vector(m: mat44, v: vec3) -> vec3f: ... @overload -def transform_inverse(t: transformh) -> transformh: +def transform_inverse(t: transform_t[]) -> transform_t[]: """ Compute the inverse of the transform. """ ... @overload -def transform_inverse(t: transformd) -> transformd: +def transform_inverse(t: transform_t[]) -> transform_t[]: """ Compute the inverse of the transform. """ ... @overload -def transform_inverse(t: transformf) -> transformf: +def transform_inverse(t: transform_t[]) -> transform_t[]: """ Compute the inverse of the transform. """ ... @overload -def transform_inverse(t: transform) -> transformf: +def transform_inverse(t: transform_t[]) -> transform_t[]: """ Compute the inverse of the transform. """ ... @overload -def spatial_dot(a: spatial_vectorh, b: spatial_vectorh) -> float16: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float64: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_dot(a: spatial_vectord, b: spatial_vectord) -> float64: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_dot(a: spatial_vectorf, b: spatial_vectorf) -> float32: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_dot(a: spatial_vectorf, b: spatial_vector) -> float32: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_dot(a: spatial_vector, b: spatial_vectorf) -> float32: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float32: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_dot(a: spatial_vector, b: spatial_vector) -> float32: +def spatial_dot(a: spatial_vector_t[], b: spatial_vector_t[]) -> float16: """ Compute the dot product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross(a: spatial_vector, b: spatial_vector) -> spatial_vectorf: +def spatial_cross(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vectorh, b: spatial_vectorh) -> spatial_vectorh: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vectord, b: spatial_vectord) -> spatial_vectord: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vectorf, b: spatial_vectorf) -> spatial_vectorf: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vectorf, b: spatial_vector) -> spatial_vectorf: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vector, b: spatial_vectorf) -> spatial_vectorf: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_cross_dual(a: spatial_vector, b: spatial_vector) -> spatial_vectorf: +def spatial_cross_dual(a: spatial_vector_t[], b: spatial_vector_t[]) -> spatial_vector_t[]: """ Compute the dual cross-product of two 6d screw vectors. """ ... @overload -def spatial_top(a: spatial_vectorh) -> vec3h: +def spatial_top(a: spatial_vector_t[]) -> vec[3, ]: """ Return the top (first) part of a 6d screw vector. """ ... @overload -def spatial_top(a: spatial_vectord) -> vec3d: +def spatial_top(a: spatial_vector_t[]) -> vec[3, ]: """ Return the top (first) part of a 6d screw vector. """ ... @overload -def spatial_top(a: spatial_vectorf) -> vec3f: +def spatial_top(a: spatial_vector_t[]) -> vec[3, ]: """ Return the top (first) part of a 6d screw vector. """ ... @overload -def spatial_top(a: spatial_vector) -> vec3f: +def spatial_top(a: spatial_vector_t[]) -> vec[3, ]: """ Return the top (first) part of a 6d screw vector. """ ... @overload -def spatial_bottom(a: spatial_vectorh) -> vec3h: +def spatial_bottom(a: spatial_vector_t[]) -> vec[3, ]: """ Return the bottom (second) part of a 6d screw vector. """ ... @overload -def spatial_bottom(a: spatial_vectord) -> vec3d: +def spatial_bottom(a: spatial_vector_t[]) -> vec[3, ]: """ Return the bottom (second) part of a 6d screw vector. """ ... @overload -def spatial_bottom(a: spatial_vectorf) -> vec3f: +def spatial_bottom(a: spatial_vector_t[]) -> vec[3, ]: """ Return the bottom (second) part of a 6d screw vector. """ ... @overload -def spatial_bottom(a: spatial_vector) -> vec3f: +def spatial_bottom(a: spatial_vector_t[]) -> vec[3, ]: """ Return the bottom (second) part of a 6d screw vector. """ ... @overload -def spatial_jacobian(S: array[vector_t], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]): +def spatial_jacobian(S: array[spatial_vector_t[~Float]], joint_parents: array[int32], joint_qd_start: array[int32], joint_start: int32, joint_count: int32, J_start: int32, J_out: array[Float]): """ """ ... @overload -def spatial_mass(I_s: array[matrix_t], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]): +def spatial_mass(I_s: array[spatial_matrix_t[~Float]], joint_start: int32, joint_count: int32, M_start: int32, M: array[Float]): """ """ @@ -4405,7 +4405,7 @@ def mlp(weights: array[float32], bias: array[float32], activation: Callable, ind ... @overload -def bvh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> bvh_query_t: +def bvh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4417,7 +4417,7 @@ def bvh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> bvh_query_t: ... @overload -def bvh_query_ray(id: uint64, start: vec3, dir: vec3) -> bvh_query_t: +def bvh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ]) -> 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. Returns an object that is used to track state during bvh traversal. @@ -4437,7 +4437,7 @@ def bvh_query_next(query: bvh_query_t, index: int32) -> bool: ... @overload -def mesh_query_point(id: uint64, point: vec3, max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool: +def mesh_query_point(id: uint64, point: vec[3, ], max_dist: float32, inside: float32, face: int32, bary_u: float32, bary_v: float32) -> bool: """ Computes the closest point on the mesh with identifier `id` to the given point in space. Returns ``True`` if a point < ``max_dist`` is found. @@ -4452,7 +4452,7 @@ def mesh_query_point(id: uint64, point: vec3, max_dist: float32, inside: float32 ... @overload -def mesh_query_ray(id: uint64, start: vec3, dir: vec3, max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec3, face: int32) -> bool: +def mesh_query_ray(id: uint64, start: vec[3, ], dir: vec[3, ], max_t: float32, t: float32, bary_u: float32, bary_v: float32, sign: float32, normal: vec[3, ], face: int32) -> bool: """ Computes the closest ray hit on the mesh with identifier `id`, returns ``True`` if a point < ``max_t`` is found. @@ -4470,7 +4470,7 @@ def mesh_query_ray(id: uint64, start: vec3, dir: vec3, max_t: float32, t: float3 ... @overload -def mesh_query_aabb(id: uint64, lower: vec3, upper: vec3) -> mesh_query_aabb_t: +def mesh_query_aabb(id: uint64, lower: vec[3, ], upper: vec[3, ]) -> mesh_query_aabb_t: """ Construct an axis-aligned bounding box query against a mesh object. This query can be used to iterate over all triangles inside a volume. Returns an object that is used to track state during mesh traversal. @@ -4490,21 +4490,21 @@ def mesh_query_aabb_next(query: mesh_query_aabb_t, index: int32) -> bool: ... @overload -def mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3: +def mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ]: """ Evaluates the position on the mesh given a face index, and barycentric coordinates. """ ... @overload -def mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3: +def mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec[3, ]: """ Evaluates the velocity on the mesh given a face index, and barycentric coordinates. """ ... @overload -def hash_grid_query(id: uint64, point: vec3, max_dist: float32) -> hash_grid_query_t: +def hash_grid_query(id: uint64, point: vec[3, ], max_dist: float32) -> hash_grid_query_t: """ Construct a point query against a hash grid. This query can be used to iterate over all neighboring points withing a fixed radius from the query point. Returns an object that is used to track state during neighbor traversal. @@ -4528,7 +4528,7 @@ def hash_grid_point_id(id: uint64, index: int32) -> int: ... @overload -def intersect_tri_tri(v0: vec3, v1: vec3, v2: vec3, u0: vec3, u1: vec3, u2: vec3) -> int: +def intersect_tri_tri(v0: vec[3, ], v1: vec[3, ], v2: vec[3, ], u0: vec[3, ], u1: vec[3, ], u2: vec[3, ]) -> int: """ Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method. Returns > 0 if triangles intersect. """ @@ -4542,21 +4542,21 @@ def mesh_get(id: uint64) -> Mesh: ... @overload -def mesh_eval_face_normal(id: uint64, face: int32) -> vec3: +def mesh_eval_face_normal(id: uint64, face: int32) -> vec[3, ]: """ Evaluates the face normal the mesh given a face index. """ ... @overload -def mesh_get_point(id: uint64, index: int32) -> vec3: +def mesh_get_point(id: uint64, index: int32) -> vec[3, ]: """ Returns the point of the mesh given a index. """ ... @overload -def mesh_get_velocity(id: uint64, index: int32) -> vec3: +def mesh_get_velocity(id: uint64, index: int32) -> vec[3, ]: """ Returns the velocity of the mesh given a index. """ @@ -4570,7 +4570,7 @@ def mesh_get_index(id: uint64, index: int32) -> int: ... @overload -def closest_point_edge_edge(p1: vec3, q1: vec3, p2: vec3, q2: vec3, epsilon: float32) -> vec3: +def closest_point_edge_edge(p1: vec[3, ], q1: vec[3, ], p2: vec[3, ], q2: vec[3, ], epsilon: float32) -> vec[3, ]: """ 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. @@ -4584,7 +4584,7 @@ def closest_point_edge_edge(p1: vec3, q1: vec3, p2: vec3, q2: vec3, epsilon: flo ... @overload -def volume_sample_f(id: uint64, uvw: vec3, sampling_mode: int32) -> float: +def volume_sample_f(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> float: """ Sample the volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` """ @@ -4605,28 +4605,28 @@ def volume_store_f(id: uint64, i: int32, j: int32, k: int32, value: float32): ... @overload -def volume_sample_v(id: uint64, uvw: vec3, sampling_mode: int32) -> vec3: +def volume_sample_v(id: uint64, uvw: vec[3, ], sampling_mode: int32) -> vec[3, ]: """ Sample the vector volume given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` """ ... @overload -def volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec3: +def volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec[3, ]: """ 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 """ ... @overload -def volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3): +def volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec[3, ]): """ Store the value at voxel with coordinates ``i``, ``j``, ``k``. """ ... @overload -def volume_sample_i(id: uint64, uvw: vec3) -> int: +def volume_sample_i(id: uint64, uvw: vec[3, ]) -> int: """ Sample the int32 volume given by ``id`` at the volume local-space point ``uvw``. """ @@ -4647,28 +4647,28 @@ def volume_store_i(id: uint64, i: int32, j: int32, k: int32, value: int32): ... @overload -def volume_index_to_world(id: uint64, uvw: vec3) -> vec3: +def volume_index_to_world(id: uint64, uvw: vec[3, ]) -> vec[3, ]: """ Transform a point defined in volume index space to world space given the volume's intrinsic affine transformation. """ ... @overload -def volume_world_to_index(id: uint64, xyz: vec3) -> vec3: +def volume_world_to_index(id: uint64, xyz: vec[3, ]) -> vec[3, ]: """ Transform a point defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. """ ... @overload -def volume_index_to_world_dir(id: uint64, uvw: vec3) -> vec3: +def volume_index_to_world_dir(id: uint64, uvw: vec[3, ]) -> vec[3, ]: """ Transform a direction defined in volume index space to world space given the volume's intrinsic affine transformation. """ ... @overload -def volume_world_to_index_dir(id: uint64, xyz: vec3) -> vec3: +def volume_world_to_index_dir(id: uint64, xyz: vec[3, ]) -> vec[3, ]: """ Transform a direction defined in volume world space to the volume's index space, given the volume's intrinsic affine transformation. """ @@ -4733,63 +4733,63 @@ def sample_cdf(state: uint32, cdf: array[float32]) -> int: ... @overload -def sample_triangle(state: uint32) -> vec2: +def sample_triangle(state: uint32) -> vec[2, ]: """ Uniformly sample a triangle. Returns sample barycentric coordinates """ ... @overload -def sample_unit_ring(state: uint32) -> vec2: +def sample_unit_ring(state: uint32) -> vec[2, ]: """ Uniformly sample a ring in the xy plane """ ... @overload -def sample_unit_disk(state: uint32) -> vec2: +def sample_unit_disk(state: uint32) -> vec[2, ]: """ Uniformly sample a disk in the xy plane """ ... @overload -def sample_unit_sphere_surface(state: uint32) -> vec3: +def sample_unit_sphere_surface(state: uint32) -> vec[3, ]: """ Uniformly sample a unit sphere surface """ ... @overload -def sample_unit_sphere(state: uint32) -> vec3: +def sample_unit_sphere(state: uint32) -> vec[3, ]: """ Uniformly sample a unit sphere """ ... @overload -def sample_unit_hemisphere_surface(state: uint32) -> vec3: +def sample_unit_hemisphere_surface(state: uint32) -> vec[3, ]: """ Uniformly sample a unit hemisphere surface """ ... @overload -def sample_unit_hemisphere(state: uint32) -> vec3: +def sample_unit_hemisphere(state: uint32) -> vec[3, ]: """ Uniformly sample a unit hemisphere """ ... @overload -def sample_unit_square(state: uint32) -> vec2: +def sample_unit_square(state: uint32) -> vec[2, ]: """ Uniformly sample a unit square """ ... @overload -def sample_unit_cube(state: uint32) -> vec3: +def sample_unit_cube(state: uint32) -> vec[3, ]: """ Uniformly sample a unit cube """ @@ -4803,21 +4803,21 @@ def noise(state: uint32, x: float32) -> float: ... @overload -def noise(state: uint32, xy: vec2) -> float: +def noise(state: uint32, xy: vec[2, ]) -> float: """ Non-periodic Perlin-style noise in 2d. """ ... @overload -def noise(state: uint32, xyz: vec3) -> float: +def noise(state: uint32, xyz: vec[3, ]) -> float: """ Non-periodic Perlin-style noise in 3d. """ ... @overload -def noise(state: uint32, xyzt: vec4) -> float: +def noise(state: uint32, xyzt: vec[4, ]) -> float: """ Non-periodic Perlin-style noise in 4d. """ @@ -4831,42 +4831,42 @@ def pnoise(state: uint32, x: float32, px: int32) -> float: ... @overload -def pnoise(state: uint32, xy: vec2, px: int32, py: int32) -> float: +def pnoise(state: uint32, xy: vec[2, ], px: int32, py: int32) -> float: """ Periodic Perlin-style noise in 2d. """ ... @overload -def pnoise(state: uint32, xyz: vec3, px: int32, py: int32, pz: int32) -> float: +def pnoise(state: uint32, xyz: vec[3, ], px: int32, py: int32, pz: int32) -> float: """ Periodic Perlin-style noise in 3d. """ ... @overload -def pnoise(state: uint32, xyzt: vec4, px: int32, py: int32, pz: int32, pt: int32) -> float: +def pnoise(state: uint32, xyzt: vec[4, ], px: int32, py: int32, pz: int32, pt: int32) -> float: """ Periodic Perlin-style noise in 4d. """ ... @overload -def curlnoise(state: uint32, xy: vec2) -> vec2: +def curlnoise(state: uint32, xy: vec[2, ]) -> vec[2, ]: """ Divergence-free vector field based on the gradient of a Perlin noise function. """ ... @overload -def curlnoise(state: uint32, xyz: vec3) -> vec3: +def curlnoise(state: uint32, xyz: vec[3, ]) -> vec[3, ]: """ Divergence-free vector field based on the curl of three Perlin noise functions. """ ... @overload -def curlnoise(state: uint32, xyzt: vec4) -> vec3: +def curlnoise(state: uint32, xyzt: vec[4, ]) -> vec[3, ]: """ Divergence-free vector field based on the curl of three Perlin noise functions. """ @@ -5105,966 +5105,966 @@ def expect_eq(arg1: float64, arg2: float64): ... @overload -def expect_eq(arg1: quath, arg2: quath): +def expect_eq(arg1: quaternion[], arg2: quaternion[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: quatf, arg2: quatf): +def expect_eq(arg1: quaternion[], arg2: quaternion[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: quatd, arg2: quatd): +def expect_eq(arg1: quaternion[], arg2: quaternion[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: quat, arg2: quat): +def expect_eq(arg1: quaternion[], arg2: quaternion[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: transformh, arg2: transformh): +def expect_eq(arg1: transform_t[], arg2: transform_t[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: transformf, arg2: transformf): +def expect_eq(arg1: transform_t[], arg2: transform_t[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: transformd, arg2: transformd): +def expect_eq(arg1: transform_t[], arg2: transform_t[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: transform, arg2: transform): +def expect_eq(arg1: transform_t[], arg2: transform_t[]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2h, arg2: vec2h): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3h, arg2: vec3h): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4h, arg2: vec4h): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2d, arg2: vec2d): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3d, arg2: vec3d): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4d, arg2: vec4d): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2ub, arg2: vec2ub): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3ub, arg2: vec3ub): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4ub, arg2: vec4ub): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2f, arg2: vec2f): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2f, arg2: vec2): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2, arg2: vec2f): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec2, arg2: vec2): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3f, arg2: vec3f): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3f, arg2: vec3): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3, arg2: vec3f): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec3, arg2: vec3): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4f, arg2: vec4f): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4f, arg2: vec4): +def expect_eq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4, arg2: vec4f): +def expect_eq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: vec4, arg2: vec4): +def expect_eq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22h, arg2: mat22h): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33h, arg2: mat33h): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44h, arg2: mat44h): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22d, arg2: mat22d): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33d, arg2: mat33d): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44d, arg2: mat44d): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22f, arg2: mat22f): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22f, arg2: mat22): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22, arg2: mat22f): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat22, arg2: mat22): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33f, arg2: mat33f): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33f, arg2: mat33): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33, arg2: mat33f): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat33, arg2: mat33): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44f, arg2: mat44f): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44f, arg2: mat44): +def expect_eq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44, arg2: mat44f): +def expect_eq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_eq(arg1: mat44, arg2: mat44): +def expect_eq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are not equal """ ... @overload -def expect_neq(arg1: vec2h, arg2: vec2h): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3h, arg2: vec3h): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4h, arg2: vec4h): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2d, arg2: vec2d): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3d, arg2: vec3d): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4d, arg2: vec4d): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2ub, arg2: vec2ub): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3ub, arg2: vec3ub): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4ub, arg2: vec4ub): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2f, arg2: vec2f): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2f, arg2: vec2): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2, arg2: vec2f): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec2, arg2: vec2): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3f, arg2: vec3f): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3f, arg2: vec3): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3, arg2: vec3f): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec3, arg2: vec3): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4f, arg2: vec4f): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4f, arg2: vec4): +def expect_neq(arg1: vec[2, ], arg2: vec[2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4, arg2: vec4f): +def expect_neq(arg1: vec[3, ], arg2: vec[3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: vec4, arg2: vec4): +def expect_neq(arg1: vec[4, ], arg2: vec[4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22h, arg2: mat22h): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33h, arg2: mat33h): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44h, arg2: mat44h): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22d, arg2: mat22d): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33d, arg2: mat33d): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44d, arg2: mat44d): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22f, arg2: mat22f): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22f, arg2: mat22): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22, arg2: mat22f): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat22, arg2: mat22): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33f, arg2: mat33f): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33f, arg2: mat33): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33, arg2: mat33f): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat33, arg2: mat33): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44f, arg2: mat44f): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44f, arg2: mat44): +def expect_neq(arg1: mat[2, 2, ], arg2: mat[2, 2, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44, arg2: mat44f): +def expect_neq(arg1: mat[3, 3, ], arg2: mat[3, 3, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def expect_neq(arg1: mat44, arg2: mat44): +def expect_neq(arg1: mat[4, 4, ], arg2: mat[4, 4, ]): """ Prints an error to stdout if arg1 and arg2 are equal """ ... @overload -def lerp(a: float16, b: float16, t: float16) -> float16: +def lerp(a: float64, b: float64, t: float64) -> float64: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: float64, b: float64, t: float64) -> float64: +def lerp(a: float32, b: float32, t: float32) -> float32: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: float32, b: float32, t: float32) -> float32: +def lerp(a: float16, b: float16, t: float16) -> float16: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec2h, b: vec2h, t: float16) -> vec2h: +def lerp(a: vec[2, ], b: vec[2, ], t: float16) -> vec[2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec2f, b: vec2f, t: float32) -> vec2f: +def lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec2d, b: vec2d, t: float64) -> vec2d: +def lerp(a: vec[2, ], b: vec[2, ], t: float64) -> vec[2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec2, b: vec2, t: float32) -> vec2: +def lerp(a: vec[2, ], b: vec[2, ], t: float32) -> vec[2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec3h, b: vec3h, t: float16) -> vec3h: +def lerp(a: vec[3, ], b: vec[3, ], t: float16) -> vec[3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec3f, b: vec3f, t: float32) -> vec3f: +def lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec3d, b: vec3d, t: float64) -> vec3d: +def lerp(a: vec[3, ], b: vec[3, ], t: float64) -> vec[3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec3, b: vec3, t: float32) -> vec3: +def lerp(a: vec[3, ], b: vec[3, ], t: float32) -> vec[3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec4h, b: vec4h, t: float16) -> vec4h: +def lerp(a: vec[4, ], b: vec[4, ], t: float16) -> vec[4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec4f, b: vec4f, t: float32) -> vec4f: +def lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec4d, b: vec4d, t: float64) -> vec4d: +def lerp(a: vec[4, ], b: vec[4, ], t: float64) -> vec[4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: vec4, b: vec4, t: float32) -> vec4: +def lerp(a: vec[4, ], b: vec[4, ], t: float32) -> vec[4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat22h, b: mat22h, t: float16) -> mat22h: +def lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float16) -> mat[2, 2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat22f, b: mat22f, t: float32) -> mat22f: +def lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat22d, b: mat22d, t: float64) -> mat22d: +def lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float64) -> mat[2, 2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat22, b: mat22, t: float32) -> mat22: +def lerp(a: mat[2, 2, ], b: mat[2, 2, ], t: float32) -> mat[2, 2, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat33h, b: mat33h, t: float16) -> mat33h: +def lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float16) -> mat[3, 3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat33f, b: mat33f, t: float32) -> mat33f: +def lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat33d, b: mat33d, t: float64) -> mat33d: +def lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float64) -> mat[3, 3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat33, b: mat33, t: float32) -> mat33: +def lerp(a: mat[3, 3, ], b: mat[3, 3, ], t: float32) -> mat[3, 3, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat44h, b: mat44h, t: float16) -> mat44h: +def lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float16) -> mat[4, 4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat44f, b: mat44f, t: float32) -> mat44f: +def lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat44d, b: mat44d, t: float64) -> mat44d: +def lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float64) -> mat[4, 4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: mat44, b: mat44, t: float32) -> mat44: +def lerp(a: mat[4, 4, ], b: mat[4, 4, ], t: float32) -> mat[4, 4, ]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: quath, b: quath, t: float16) -> quath: +def lerp(a: quaternion[], b: quaternion[], t: float16) -> quaternion[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: quatf, b: quatf, t: float32) -> quatf: +def lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: quatd, b: quatd, t: float64) -> quatd: +def lerp(a: quaternion[], b: quaternion[], t: float64) -> quaternion[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: quat, b: quat, t: float32) -> quat: +def lerp(a: quaternion[], b: quaternion[], t: float32) -> quaternion[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: transformh, b: transformh, t: float16) -> transformh: +def lerp(a: transform_t[], b: transform_t[], t: float16) -> transform_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: transformf, b: transformf, t: float32) -> transformf: +def lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: transformd, b: transformd, t: float64) -> transformd: +def lerp(a: transform_t[], b: transform_t[], t: float64) -> transform_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: transform, b: transform, t: float32) -> transform: +def lerp(a: transform_t[], b: transform_t[], t: float32) -> transform_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_vectorh, b: spatial_vectorh, t: float16) -> spatial_vectorh: +def lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float16) -> spatial_vector_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_vectorf, b: spatial_vectorf, t: float32) -> spatial_vectorf: +def lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_vectord, b: spatial_vectord, t: float64) -> spatial_vectord: +def lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float64) -> spatial_vector_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_vector, b: spatial_vector, t: float32) -> spatial_vector: +def lerp(a: spatial_vector_t[], b: spatial_vector_t[], t: float32) -> spatial_vector_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_matrixh, b: spatial_matrixh, t: float16) -> spatial_matrixh: +def lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float16) -> spatial_matrix_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_matrixf, b: spatial_matrixf, t: float32) -> spatial_matrixf: +def lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_matrixd, b: spatial_matrixd, t: float64) -> spatial_matrixd: +def lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float64) -> spatial_matrix_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def lerp(a: spatial_matrix, b: spatial_matrix, t: float32) -> spatial_matrix: +def lerp(a: spatial_matrix_t[], b: spatial_matrix_t[], t: float32) -> spatial_matrix_t[]: """ Linearly interpolate two values a and b using factor t, computed as ``a*(1-t) + b*t`` """ ... @overload -def smoothstep(edge0: float16, edge1: float16, x: float16) -> float16: +def smoothstep(edge0: float64, edge1: float64, x: float64) -> float64: """ 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 """ ... @overload -def smoothstep(edge0: float64, edge1: float64, x: float64) -> float64: +def smoothstep(edge0: float32, edge1: float32, x: float32) -> float32: """ 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 """ ... @overload -def smoothstep(edge0: float32, edge1: float32, x: float32) -> float32: +def smoothstep(edge0: float16, edge1: float16, x: float16) -> float16: """ 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 """ ... @overload -def expect_near(arg1: float16, arg2: float16, tolerance: float16): +def expect_near(arg1: float64, arg2: float64, tolerance: float64): """ Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude """ ... @overload -def expect_near(arg1: float64, arg2: float64, tolerance: float64): +def expect_near(arg1: float32, arg2: float32, tolerance: float32): """ Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude """ ... @overload -def expect_near(arg1: float32, arg2: float32, tolerance: float32): +def expect_near(arg1: float16, arg2: float16, tolerance: float16): """ Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude """ ... @overload -def expect_near(arg1: vec3, arg2: vec3, tolerance: float32): +def expect_near(arg1: vec[3, ], arg2: vec[3, ], tolerance: float32): """ Prints an error to stdout if any element of arg1 and arg2 are not closer than tolerance in magnitude """ ... @overload -def lower_bound(arr: array[Scalar], value: int32) -> int: +def lower_bound(arr: array[Scalar], value: uint32) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ ... @overload -def lower_bound(arr: array[Scalar], value: int8) -> int: +def lower_bound(arr: array[Scalar], value: int16) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ @@ -6078,21 +6078,28 @@ def lower_bound(arr: array[Scalar], value: float64) -> int: ... @overload -def lower_bound(arr: array[Scalar], value: int16) -> int: +def lower_bound(arr: array[Scalar], value: int8) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ ... @overload -def lower_bound(arr: array[Scalar], value: uint32) -> int: +def lower_bound(arr: array[Scalar], value: float16) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ ... @overload -def lower_bound(arr: array[Scalar], value: float16) -> int: +def lower_bound(arr: array[Scalar], value: uint16) -> int: + """ + Search a sorted array for the closest element greater than or equal to value. + """ + ... + +@overload +def lower_bound(arr: array[Scalar], value: int32) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ @@ -6106,7 +6113,7 @@ def lower_bound(arr: array[Scalar], value: uint64) -> int: ... @overload -def lower_bound(arr: array[Scalar], value: uint16) -> int: +def lower_bound(arr: array[Scalar], value: float32) -> int: """ Search a sorted array for the closest element greater than or equal to value. """ @@ -6127,49 +6134,49 @@ def lower_bound(arr: array[Scalar], value: uint8) -> int: ... @overload -def lower_bound(arr: array[Scalar], value: float32) -> int: +def add(x: uint32, y: uint32) -> uint32: """ - Search a sorted array for the closest element greater than or equal to value. + """ ... @overload -def add(x: int32, y: int32) -> int32: +def add(x: int16, y: int16) -> int16: """ """ ... @overload -def add(x: int8, y: int8) -> int8: +def add(x: float64, y: float64) -> float64: """ """ ... @overload -def add(x: float64, y: float64) -> float64: +def add(x: int8, y: int8) -> int8: """ """ ... @overload -def add(x: int16, y: int16) -> int16: +def add(x: float16, y: float16) -> float16: """ """ ... @overload -def add(x: uint32, y: uint32) -> uint32: +def add(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def add(x: float16, y: float16) -> float16: +def add(x: int32, y: int32) -> int32: """ """ @@ -6183,7 +6190,7 @@ def add(x: uint64, y: uint64) -> uint64: ... @overload -def add(x: uint16, y: uint16) -> uint16: +def add(x: float32, y: float32) -> float32: """ """ @@ -6204,490 +6211,490 @@ def add(x: uint8, y: uint8) -> uint8: ... @overload -def add(x: float32, y: float32) -> float32: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec2h, y: vec2h) -> vec2h: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec3h, y: vec3h) -> vec3h: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec4h, y: vec4h) -> vec4h: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec2d, y: vec2d) -> vec2d: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec3d, y: vec3d) -> vec3d: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec4d, y: vec4d) -> vec4d: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec2ub, y: vec2ub) -> vec2ub: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec3ub, y: vec3ub) -> vec3ub: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec4ub, y: vec4ub) -> vec4ub: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec2f, y: vec2f) -> vec2f: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec2f, y: vec2) -> vec2f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec2, y: vec2f) -> vec2f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec2, y: vec2) -> vec2f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec3f, y: vec3f) -> vec3f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec3f, y: vec3) -> vec3f: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec3, y: vec3f) -> vec3f: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec3, y: vec3) -> vec3f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec4f, y: vec4f) -> vec4f: +def add(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def add(x: vec4f, y: vec4) -> vec4f: +def add(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def add(x: vec4, y: vec4f) -> vec4f: +def add(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def add(x: vec4, y: vec4) -> vec4f: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quath, y: quath) -> quath: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quatd, y: quatd) -> quatd: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quatf, y: quatf) -> quatf: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quatf, y: quat) -> quatf: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quat, y: quatf) -> quatf: +def add(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def add(x: quat, y: quat) -> quatf: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat22h, y: mat22h) -> mat22h: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat33h, y: mat33h) -> mat33h: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat44h, y: mat44h) -> mat44h: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat22d, y: mat22d) -> mat22d: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat33d, y: mat33d) -> mat33d: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat44d, y: mat44d) -> mat44d: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat22f, y: mat22f) -> mat22f: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat22f, y: mat22) -> mat22f: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat22, y: mat22f) -> mat22f: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat22, y: mat22) -> mat22f: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat33f, y: mat33f) -> mat33f: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat33f, y: mat33) -> mat33f: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat33, y: mat33f) -> mat33f: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat33, y: mat33) -> mat33f: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat44f, y: mat44f) -> mat44f: +def add(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def add(x: mat44f, y: mat44) -> mat44f: +def add(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def add(x: mat44, y: mat44f) -> mat44f: +def add(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def add(x: mat44, y: mat44) -> mat44f: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf: +def add(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def add(x: spatial_vector, y: spatial_vector) -> spatial_vectorf: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf: +def add(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def add(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transformh, y: transformh) -> transformh: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transformd, y: transformd) -> transformd: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transformf, y: transformf) -> transformf: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transformf, y: transform) -> transformf: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transform, y: transformf) -> transformf: +def add(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def add(x: transform, y: transform) -> transformf: +def sub(x: uint32, y: uint32) -> uint32: """ """ ... @overload -def sub(x: int32, y: int32) -> int32: +def sub(x: int16, y: int16) -> int16: """ """ ... @overload -def sub(x: int8, y: int8) -> int8: +def sub(x: float64, y: float64) -> float64: """ """ ... @overload -def sub(x: float64, y: float64) -> float64: +def sub(x: int8, y: int8) -> int8: """ """ ... @overload -def sub(x: int16, y: int16) -> int16: +def sub(x: float16, y: float16) -> float16: """ """ ... @overload -def sub(x: uint32, y: uint32) -> uint32: +def sub(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def sub(x: float16, y: float16) -> float16: +def sub(x: int32, y: int32) -> int32: """ """ @@ -6701,7 +6708,7 @@ def sub(x: uint64, y: uint64) -> uint64: ... @overload -def sub(x: uint16, y: uint16) -> uint16: +def sub(x: float32, y: float32) -> float32: """ """ @@ -6722,490 +6729,490 @@ def sub(x: uint8, y: uint8) -> uint8: ... @overload -def sub(x: float32, y: float32) -> float32: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec2h, y: vec2h) -> vec2h: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec3h, y: vec3h) -> vec3h: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec4h, y: vec4h) -> vec4h: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec2d, y: vec2d) -> vec2d: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec3d, y: vec3d) -> vec3d: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec4d, y: vec4d) -> vec4d: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec2ub, y: vec2ub) -> vec2ub: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec3ub, y: vec3ub) -> vec3ub: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec4ub, y: vec4ub) -> vec4ub: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec2f, y: vec2f) -> vec2f: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec2f, y: vec2) -> vec2f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec2, y: vec2f) -> vec2f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec2, y: vec2) -> vec2f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec3f, y: vec3f) -> vec3f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec3f, y: vec3) -> vec3f: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec3, y: vec3f) -> vec3f: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec3, y: vec3) -> vec3f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec4f, y: vec4f) -> vec4f: +def sub(x: vec[2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def sub(x: vec4f, y: vec4) -> vec4f: +def sub(x: vec[3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def sub(x: vec4, y: vec4f) -> vec4f: +def sub(x: vec[4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def sub(x: vec4, y: vec4) -> vec4f: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat22h, y: mat22h) -> mat22h: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat33h, y: mat33h) -> mat33h: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat44h, y: mat44h) -> mat44h: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat22d, y: mat22d) -> mat22d: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat33d, y: mat33d) -> mat33d: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat44d, y: mat44d) -> mat44d: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat22f, y: mat22f) -> mat22f: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat22f, y: mat22) -> mat22f: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat22, y: mat22f) -> mat22f: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat22, y: mat22) -> mat22f: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat33f, y: mat33f) -> mat33f: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat33f, y: mat33) -> mat33f: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat33, y: mat33f) -> mat33f: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat33, y: mat33) -> mat33f: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat44f, y: mat44f) -> mat44f: +def sub(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def sub(x: mat44f, y: mat44) -> mat44f: +def sub(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def sub(x: mat44, y: mat44f) -> mat44f: +def sub(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def sub(x: mat44, y: mat44) -> mat44f: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vectorh, y: spatial_vectorh) -> spatial_vectorh: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vectord, y: spatial_vectord) -> spatial_vectord: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vectorf, y: spatial_vectorf) -> spatial_vectorf: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vectorf, y: spatial_vector) -> spatial_vectorf: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vector, y: spatial_vectorf) -> spatial_vectorf: +def sub(x: spatial_vector_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def sub(x: spatial_vector, y: spatial_vector) -> spatial_vectorf: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf: +def sub(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def sub(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quath, y: quath) -> quath: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quatd, y: quatd) -> quatd: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quatf, y: quatf) -> quatf: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quatf, y: quat) -> quatf: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quat, y: quatf) -> quatf: +def sub(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def sub(x: quat, y: quat) -> quatf: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transformh, y: transformh) -> transformh: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transformd, y: transformd) -> transformd: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transformf, y: transformf) -> transformf: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transformf, y: transform) -> transformf: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transform, y: transformf) -> transformf: +def sub(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def sub(x: transform, y: transform) -> transformf: +def mul(x: uint32, y: uint32) -> uint32: """ """ ... @overload -def mul(x: int32, y: int32) -> int32: +def mul(x: int16, y: int16) -> int16: """ """ ... @overload -def mul(x: int8, y: int8) -> int8: +def mul(x: float64, y: float64) -> float64: """ """ ... @overload -def mul(x: float64, y: float64) -> float64: +def mul(x: int8, y: int8) -> int8: """ """ ... @overload -def mul(x: int16, y: int16) -> int16: +def mul(x: float16, y: float16) -> float16: """ """ ... @overload -def mul(x: uint32, y: uint32) -> uint32: +def mul(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def mul(x: float16, y: float16) -> float16: +def mul(x: int32, y: int32) -> int32: """ """ @@ -7219,7 +7226,7 @@ def mul(x: uint64, y: uint64) -> uint64: ... @overload -def mul(x: uint16, y: uint16) -> uint16: +def mul(x: float32, y: float32) -> float32: """ """ @@ -7240,1071 +7247,1071 @@ def mul(x: uint8, y: uint8) -> uint8: ... @overload -def mul(x: float32, y: float32) -> float32: +def mul(x: vec[2, ], y: float64) -> vec[2, ]: """ """ ... @overload -def mul(x: vec2h, y: float16) -> vec2h: +def mul(x: vec[3, ], y: float64) -> vec[3, ]: """ """ ... @overload -def mul(x: vec3h, y: float16) -> vec3h: +def mul(x: vec[4, ], y: float64) -> vec[4, ]: """ """ ... @overload -def mul(x: vec4h, y: float16) -> vec4h: +def mul(x: vec[2, ], y: float16) -> vec[2, ]: """ """ ... @overload -def mul(x: vec2d, y: float64) -> vec2d: +def mul(x: vec[3, ], y: float16) -> vec[3, ]: """ """ ... @overload -def mul(x: vec3d, y: float64) -> vec3d: +def mul(x: vec[4, ], y: float16) -> vec[4, ]: """ """ ... @overload -def mul(x: vec4d, y: float64) -> vec4d: +def mul(x: vec[2, ], y: uint8) -> vec[2, ]: """ """ ... @overload -def mul(x: vec2ub, y: uint8) -> vec2ub: +def mul(x: vec[3, ], y: uint8) -> vec[3, ]: """ """ ... @overload -def mul(x: vec3ub, y: uint8) -> vec3ub: +def mul(x: vec[4, ], y: uint8) -> vec[4, ]: """ """ ... @overload -def mul(x: vec4ub, y: uint8) -> vec4ub: +def mul(x: vec[2, ], y: float32) -> vec[2, ]: """ """ ... @overload -def mul(x: vec2f, y: float32) -> vec2f: +def mul(x: vec[2, ], y: float32) -> vec[2, ]: """ """ ... @overload -def mul(x: vec2, y: float32) -> vec2f: +def mul(x: vec[3, ], y: float32) -> vec[3, ]: """ """ ... @overload -def mul(x: vec3f, y: float32) -> vec3f: +def mul(x: vec[3, ], y: float32) -> vec[3, ]: """ """ ... @overload -def mul(x: vec3, y: float32) -> vec3f: +def mul(x: vec[4, ], y: float32) -> vec[4, ]: """ """ ... @overload -def mul(x: vec4f, y: float32) -> vec4f: +def mul(x: vec[4, ], y: float32) -> vec[4, ]: """ """ ... @overload -def mul(x: vec4, y: float32) -> vec4f: +def mul(x: float64, y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: float16, y: vec2h) -> vec2h: +def mul(x: float64, y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: float16, y: vec3h) -> vec3h: +def mul(x: float64, y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: float16, y: vec4h) -> vec4h: +def mul(x: float16, y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: float64, y: vec2d) -> vec2d: +def mul(x: float16, y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: float64, y: vec3d) -> vec3d: +def mul(x: float16, y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: float64, y: vec4d) -> vec4d: +def mul(x: uint8, y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: uint8, y: vec2ub) -> vec2ub: +def mul(x: uint8, y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: uint8, y: vec3ub) -> vec3ub: +def mul(x: uint8, y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: uint8, y: vec4ub) -> vec4ub: +def mul(x: float32, y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: float32, y: vec2f) -> vec2f: +def mul(x: float32, y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: float32, y: vec2) -> vec2f: +def mul(x: float32, y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: float32, y: vec3f) -> vec3f: +def mul(x: float32, y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: float32, y: vec3) -> vec3f: +def mul(x: float32, y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: float32, y: vec4f) -> vec4f: +def mul(x: float32, y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: float32, y: vec4) -> vec4f: +def mul(x: quaternion[], y: float64) -> quaternion[]: """ """ ... @overload -def mul(x: quath, y: float16) -> quath: +def mul(x: quaternion[], y: float16) -> quaternion[]: """ """ ... @overload -def mul(x: quatd, y: float64) -> quatd: +def mul(x: quaternion[], y: float32) -> quaternion[]: """ """ ... @overload -def mul(x: quatf, y: float32) -> quatf: +def mul(x: quaternion[], y: float32) -> quaternion[]: """ """ ... @overload -def mul(x: quat, y: float32) -> quatf: +def mul(x: float64, y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: float16, y: quath) -> quath: +def mul(x: float16, y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: float64, y: quatd) -> quatd: +def mul(x: float32, y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: float32, y: quatf) -> quatf: +def mul(x: float32, y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: float32, y: quat) -> quatf: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quath, y: quath) -> quath: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quatd, y: quatd) -> quatd: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quatf, y: quatf) -> quatf: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quatf, y: quat) -> quatf: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quat, y: quatf) -> quatf: +def mul(x: quaternion[], y: quaternion[]) -> quaternion[]: """ """ ... @overload -def mul(x: quat, y: quat) -> quatf: +def mul(x: float64, y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: float16, y: mat22h) -> mat22h: +def mul(x: float64, y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: float16, y: mat33h) -> mat33h: +def mul(x: float64, y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: float16, y: mat44h) -> mat44h: +def mul(x: float16, y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: float64, y: mat22d) -> mat22d: +def mul(x: float16, y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: float64, y: mat33d) -> mat33d: +def mul(x: float16, y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: float64, y: mat44d) -> mat44d: +def mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: float32, y: mat22f) -> mat22f: +def mul(x: float32, y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: float32, y: mat22) -> mat22f: +def mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: float32, y: mat33f) -> mat33f: +def mul(x: float32, y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: float32, y: mat33) -> mat33f: +def mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: float32, y: mat44f) -> mat44f: +def mul(x: float32, y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: float32, y: mat44) -> mat44f: +def mul(x: mat[2, 2, ], y: float64) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22h, y: float16) -> mat22h: +def mul(x: mat[3, 3, ], y: float64) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33h, y: float16) -> mat33h: +def mul(x: mat[4, 4, ], y: float64) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44h, y: float16) -> mat44h: +def mul(x: mat[2, 2, ], y: float16) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22d, y: float64) -> mat22d: +def mul(x: mat[3, 3, ], y: float16) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33d, y: float64) -> mat33d: +def mul(x: mat[4, 4, ], y: float16) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44d, y: float64) -> mat44d: +def mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22f, y: float32) -> mat22f: +def mul(x: mat[2, 2, ], y: float32) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22, y: float32) -> mat22f: +def mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33f, y: float32) -> mat33f: +def mul(x: mat[3, 3, ], y: float32) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33, y: float32) -> mat33f: +def mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44f, y: float32) -> mat44f: +def mul(x: mat[4, 4, ], y: float32) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44, y: float32) -> mat44f: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22h, y: vec2h) -> vec2h: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33h, y: vec3h) -> vec3h: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44h, y: vec4h) -> vec4h: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22d, y: vec2d) -> vec2d: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33d, y: vec3d) -> vec3d: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44d, y: vec4d) -> vec4d: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22f, y: vec2f) -> vec2f: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22f, y: vec2) -> vec2f: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22, y: vec2f) -> vec2f: +def mul(x: mat[2, 2, ], y: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def mul(x: mat22, y: vec2) -> vec2f: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33f, y: vec3f) -> vec3f: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33f, y: vec3) -> vec3f: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33, y: vec3f) -> vec3f: +def mul(x: mat[3, 3, ], y: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def mul(x: mat33, y: vec3) -> vec3f: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44f, y: vec4f) -> vec4f: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44f, y: vec4) -> vec4f: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44, y: vec4f) -> vec4f: +def mul(x: mat[4, 4, ], y: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def mul(x: mat44, y: vec4) -> vec4f: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22h, y: mat22h) -> mat22h: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33h, y: mat33h) -> mat33h: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44h, y: mat44h) -> mat44h: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22d, y: mat22d) -> mat22d: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat33d, y: mat33d) -> mat33d: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat44d, y: mat44d) -> mat44d: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat22f, y: mat22f) -> mat22f: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat22f, y: mat22) -> mat22f: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat22, y: mat22f) -> mat22f: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat22, y: mat22) -> mat22f: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat33f, y: mat33f) -> mat33f: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat33f, y: mat33) -> mat33f: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat33, y: mat33f) -> mat33f: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat33, y: mat33) -> mat33f: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44f, y: mat44f) -> mat44f: +def mul(x: mat[2, 2, ], y: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def mul(x: mat44f, y: mat44) -> mat44f: +def mul(x: mat[3, 3, ], y: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def mul(x: mat44, y: mat44f) -> mat44f: +def mul(x: mat[4, 4, ], y: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def mul(x: mat44, y: mat44) -> mat44f: +def mul(x: spatial_vector_t[], y: float64) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_vectorh, y: float16) -> spatial_vectorh: +def mul(x: spatial_vector_t[], y: float16) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_vectord, y: float64) -> spatial_vectord: +def mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_vectorf, y: float32) -> spatial_vectorf: +def mul(x: spatial_vector_t[], y: float32) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_vector, y: float32) -> spatial_vectorf: +def mul(x: float64, y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: float16, y: spatial_vectorh) -> spatial_vectorh: +def mul(x: float16, y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: float64, y: spatial_vectord) -> spatial_vectord: +def mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: float32, y: spatial_vectorf) -> spatial_vectorf: +def mul(x: float32, y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: float32, y: spatial_vector) -> spatial_vectorf: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixh, y: spatial_matrixh) -> spatial_matrixh: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixd, y: spatial_matrixd) -> spatial_matrixd: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixf, y: spatial_matrixf) -> spatial_matrixf: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixf, y: spatial_matrix) -> spatial_matrixf: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrix, y: spatial_matrixf) -> spatial_matrixf: +def mul(x: spatial_matrix_t[], y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrix, y: spatial_matrix) -> spatial_matrixf: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrixh, y: spatial_vectorh) -> spatial_vectorh: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrixd, y: spatial_vectord) -> spatial_vectord: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrixf, y: spatial_vectorf) -> spatial_vectorf: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrixf, y: spatial_vector) -> spatial_vectorf: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrix, y: spatial_vectorf) -> spatial_vectorf: +def mul(x: spatial_matrix_t[], y: spatial_vector_t[]) -> spatial_vector_t[]: """ """ ... @overload -def mul(x: spatial_matrix, y: spatial_vector) -> spatial_vectorf: +def mul(x: spatial_matrix_t[], y: float64) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixh, y: float16) -> spatial_matrixh: +def mul(x: spatial_matrix_t[], y: float16) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixd, y: float64) -> spatial_matrixd: +def mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrixf, y: float32) -> spatial_matrixf: +def mul(x: spatial_matrix_t[], y: float32) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: spatial_matrix, y: float32) -> spatial_matrixf: +def mul(x: float64, y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: float16, y: spatial_matrixh) -> spatial_matrixh: +def mul(x: float16, y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: float64, y: spatial_matrixd) -> spatial_matrixd: +def mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: float32, y: spatial_matrixf) -> spatial_matrixf: +def mul(x: float32, y: spatial_matrix_t[]) -> spatial_matrix_t[]: """ """ ... @overload -def mul(x: float32, y: spatial_matrix) -> spatial_matrixf: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transformh, y: transformh) -> transformh: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transformd, y: transformd) -> transformd: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transformf, y: transformf) -> transformf: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transformf, y: transform) -> transformf: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transform, y: transformf) -> transformf: +def mul(x: transform_t[], y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: transform, y: transform) -> transformf: +def mul(x: float64, y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: float16, y: transformh) -> transformh: +def mul(x: float16, y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: float64, y: transformd) -> transformd: +def mul(x: float32, y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: float32, y: transformf) -> transformf: +def mul(x: float32, y: transform_t[]) -> transform_t[]: """ """ ... @overload -def mul(x: float32, y: transform) -> transformf: +def mul(x: transform_t[], y: float64) -> transform_t[]: """ """ ... @overload -def mul(x: transformh, y: float16) -> transformh: +def mul(x: transform_t[], y: float16) -> transform_t[]: """ """ ... @overload -def mul(x: transformd, y: float64) -> transformd: +def mul(x: transform_t[], y: float32) -> transform_t[]: """ """ ... @overload -def mul(x: transformf, y: float32) -> transformf: +def mul(x: transform_t[], y: float32) -> transform_t[]: """ """ ... @overload -def mul(x: transform, y: float32) -> transformf: +def mod(x: uint32, y: uint32) -> uint32: """ """ ... @overload -def mod(x: int32, y: int32) -> int32: +def mod(x: int16, y: int16) -> int16: """ """ ... @overload -def mod(x: int8, y: int8) -> int8: +def mod(x: float64, y: float64) -> float64: """ """ ... @overload -def mod(x: float64, y: float64) -> float64: +def mod(x: int8, y: int8) -> int8: """ """ ... @overload -def mod(x: int16, y: int16) -> int16: +def mod(x: float16, y: float16) -> float16: """ """ ... @overload -def mod(x: uint32, y: uint32) -> uint32: +def mod(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def mod(x: float16, y: float16) -> float16: +def mod(x: int32, y: int32) -> int32: """ """ @@ -8318,7 +8325,7 @@ def mod(x: uint64, y: uint64) -> uint64: ... @overload -def mod(x: uint16, y: uint16) -> uint16: +def mod(x: float32, y: float32) -> float32: """ """ @@ -8339,49 +8346,49 @@ def mod(x: uint8, y: uint8) -> uint8: ... @overload -def mod(x: float32, y: float32) -> float32: +def div(x: uint32, y: uint32) -> uint32: """ """ ... @overload -def div(x: int32, y: int32) -> int32: +def div(x: int16, y: int16) -> int16: """ """ ... @overload -def div(x: int8, y: int8) -> int8: +def div(x: float64, y: float64) -> float64: """ """ ... @overload -def div(x: float64, y: float64) -> float64: +def div(x: int8, y: int8) -> int8: """ """ ... @overload -def div(x: int16, y: int16) -> int16: +def div(x: float16, y: float16) -> float16: """ """ ... @overload -def div(x: uint32, y: uint32) -> uint32: +def div(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def div(x: float16, y: float16) -> float16: +def div(x: int32, y: int32) -> int32: """ """ @@ -8395,7 +8402,7 @@ def div(x: uint64, y: uint64) -> uint64: ... @overload -def div(x: uint16, y: uint16) -> uint16: +def div(x: float32, y: float32) -> float32: """ """ @@ -8416,266 +8423,266 @@ def div(x: uint8, y: uint8) -> uint8: ... @overload -def div(x: float32, y: float32) -> float32: +def div(x: vec[2, ], y: float64) -> vec[2, ]: """ """ ... @overload -def div(x: vec2h, y: float16) -> vec2h: +def div(x: vec[3, ], y: float64) -> vec[3, ]: """ """ ... @overload -def div(x: vec3h, y: float16) -> vec3h: +def div(x: vec[4, ], y: float64) -> vec[4, ]: """ """ ... @overload -def div(x: vec4h, y: float16) -> vec4h: +def div(x: vec[2, ], y: float16) -> vec[2, ]: """ """ ... @overload -def div(x: vec2d, y: float64) -> vec2d: +def div(x: vec[3, ], y: float16) -> vec[3, ]: """ """ ... @overload -def div(x: vec3d, y: float64) -> vec3d: +def div(x: vec[4, ], y: float16) -> vec[4, ]: """ """ ... @overload -def div(x: vec4d, y: float64) -> vec4d: +def div(x: vec[2, ], y: uint8) -> vec[2, ]: """ """ ... @overload -def div(x: vec2ub, y: uint8) -> vec2ub: +def div(x: vec[3, ], y: uint8) -> vec[3, ]: """ """ ... @overload -def div(x: vec3ub, y: uint8) -> vec3ub: +def div(x: vec[4, ], y: uint8) -> vec[4, ]: """ """ ... @overload -def div(x: vec4ub, y: uint8) -> vec4ub: +def div(x: vec[2, ], y: float32) -> vec[2, ]: """ """ ... @overload -def div(x: vec2f, y: float32) -> vec2f: +def div(x: vec[2, ], y: float32) -> vec[2, ]: """ """ ... @overload -def div(x: vec2, y: float32) -> vec2f: +def div(x: vec[3, ], y: float32) -> vec[3, ]: """ """ ... @overload -def div(x: vec3f, y: float32) -> vec3f: +def div(x: vec[3, ], y: float32) -> vec[3, ]: """ """ ... @overload -def div(x: vec3, y: float32) -> vec3f: +def div(x: vec[4, ], y: float32) -> vec[4, ]: """ """ ... @overload -def div(x: vec4f, y: float32) -> vec4f: +def div(x: vec[4, ], y: float32) -> vec[4, ]: """ """ ... @overload -def div(x: vec4, y: float32) -> vec4f: +def div(x: mat[2, 2, ], y: float64) -> mat[2, 2, ]: """ """ ... @overload -def div(x: mat22h, y: float16) -> mat22h: +def div(x: mat[3, 3, ], y: float64) -> mat[3, 3, ]: """ """ ... @overload -def div(x: mat33h, y: float16) -> mat33h: +def div(x: mat[4, 4, ], y: float64) -> mat[4, 4, ]: """ """ ... @overload -def div(x: mat44h, y: float16) -> mat44h: +def div(x: mat[2, 2, ], y: float16) -> mat[2, 2, ]: """ """ ... @overload -def div(x: mat22d, y: float64) -> mat22d: +def div(x: mat[3, 3, ], y: float16) -> mat[3, 3, ]: """ """ ... @overload -def div(x: mat33d, y: float64) -> mat33d: +def div(x: mat[4, 4, ], y: float16) -> mat[4, 4, ]: """ """ ... @overload -def div(x: mat44d, y: float64) -> mat44d: +def div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ]: """ """ ... @overload -def div(x: mat22f, y: float32) -> mat22f: +def div(x: mat[2, 2, ], y: float32) -> mat[2, 2, ]: """ """ ... @overload -def div(x: mat22, y: float32) -> mat22f: +def div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ]: """ """ ... @overload -def div(x: mat33f, y: float32) -> mat33f: +def div(x: mat[3, 3, ], y: float32) -> mat[3, 3, ]: """ """ ... @overload -def div(x: mat33, y: float32) -> mat33f: +def div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ]: """ """ ... @overload -def div(x: mat44f, y: float32) -> mat44f: +def div(x: mat[4, 4, ], y: float32) -> mat[4, 4, ]: """ """ ... @overload -def div(x: mat44, y: float32) -> mat44f: +def div(x: quaternion[], y: float64) -> quaternion[]: """ """ ... @overload -def div(x: quath, y: float16) -> quath: +def div(x: quaternion[], y: float16) -> quaternion[]: """ """ ... @overload -def div(x: quatd, y: float64) -> quatd: +def div(x: quaternion[], y: float32) -> quaternion[]: """ """ ... @overload -def div(x: quatf, y: float32) -> quatf: +def div(x: quaternion[], y: float32) -> quaternion[]: """ """ ... @overload -def div(x: quat, y: float32) -> quatf: +def floordiv(x: uint32, y: uint32) -> uint32: """ """ ... @overload -def floordiv(x: int32, y: int32) -> int32: +def floordiv(x: int16, y: int16) -> int16: """ """ ... @overload -def floordiv(x: int8, y: int8) -> int8: +def floordiv(x: float64, y: float64) -> float64: """ """ ... @overload -def floordiv(x: float64, y: float64) -> float64: +def floordiv(x: int8, y: int8) -> int8: """ """ ... @overload -def floordiv(x: int16, y: int16) -> int16: +def floordiv(x: float16, y: float16) -> float16: """ """ ... @overload -def floordiv(x: uint32, y: uint32) -> uint32: +def floordiv(x: uint16, y: uint16) -> uint16: """ """ ... @overload -def floordiv(x: float16, y: float16) -> float16: +def floordiv(x: int32, y: int32) -> int32: """ """ @@ -8689,7 +8696,7 @@ def floordiv(x: uint64, y: uint64) -> uint64: ... @overload -def floordiv(x: uint16, y: uint16) -> uint16: +def floordiv(x: float32, y: float32) -> float32: """ """ @@ -8710,49 +8717,49 @@ def floordiv(x: uint8, y: uint8) -> uint8: ... @overload -def floordiv(x: float32, y: float32) -> float32: +def neg(x: uint32) -> uint32: """ """ ... @overload -def neg(x: int32) -> int32: +def neg(x: int16) -> int16: """ """ ... @overload -def neg(x: int8) -> int8: +def neg(x: float64) -> float64: """ """ ... @overload -def neg(x: float64) -> float64: +def neg(x: int8) -> int8: """ """ ... @overload -def neg(x: int16) -> int16: +def neg(x: float16) -> float16: """ """ ... @overload -def neg(x: uint32) -> uint32: +def neg(x: uint16) -> uint16: """ """ ... @overload -def neg(x: float16) -> float16: +def neg(x: int32) -> int32: """ """ @@ -8766,7 +8773,7 @@ def neg(x: uint64) -> uint64: ... @overload -def neg(x: uint16) -> uint16: +def neg(x: float32) -> float32: """ """ @@ -8787,224 +8794,217 @@ def neg(x: uint8) -> uint8: ... @overload -def neg(x: float32) -> float32: - """ - - """ - ... - -@overload -def neg(x: vec2h) -> vec2h: +def neg(x: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def neg(x: vec3h) -> vec3h: +def neg(x: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def neg(x: vec4h) -> vec4h: +def neg(x: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def neg(x: vec2d) -> vec2d: +def neg(x: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def neg(x: vec3d) -> vec3d: +def neg(x: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def neg(x: vec4d) -> vec4d: +def neg(x: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def neg(x: vec2ub) -> vec2ub: +def neg(x: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def neg(x: vec3ub) -> vec3ub: +def neg(x: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def neg(x: vec4ub) -> vec4ub: +def neg(x: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def neg(x: vec2f) -> vec2f: +def neg(x: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def neg(x: vec2) -> vec2f: +def neg(x: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def neg(x: vec3f) -> vec3f: +def neg(x: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def neg(x: vec3) -> vec3f: +def neg(x: vec[2, ]) -> vec[2, ]: """ """ ... @overload -def neg(x: vec4f) -> vec4f: +def neg(x: vec[3, ]) -> vec[3, ]: """ """ ... @overload -def neg(x: vec4) -> vec4f: +def neg(x: vec[4, ]) -> vec[4, ]: """ """ ... @overload -def neg(x: quath) -> quath: +def neg(x: quaternion[]) -> quaternion[]: """ """ ... @overload -def neg(x: quatd) -> quatd: +def neg(x: quaternion[]) -> quaternion[]: """ """ ... @overload -def neg(x: quatf) -> quatf: +def neg(x: quaternion[]) -> quaternion[]: """ """ ... @overload -def neg(x: quat) -> quatf: +def neg(x: quaternion[]) -> quaternion[]: """ """ ... @overload -def neg(x: mat22h) -> mat22h: +def neg(x: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def neg(x: mat33h) -> mat33h: +def neg(x: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def neg(x: mat44h) -> mat44h: +def neg(x: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def neg(x: mat22d) -> mat22d: +def neg(x: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def neg(x: mat33d) -> mat33d: +def neg(x: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def neg(x: mat44d) -> mat44d: +def neg(x: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def neg(x: mat22f) -> mat22f: +def neg(x: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def neg(x: mat22) -> mat22f: +def neg(x: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def neg(x: mat33f) -> mat33f: +def neg(x: mat[4, 4, ]) -> mat[4, 4, ]: """ """ ... @overload -def neg(x: mat33) -> mat33f: +def neg(x: mat[2, 2, ]) -> mat[2, 2, ]: """ """ ... @overload -def neg(x: mat44f) -> mat44f: +def neg(x: mat[3, 3, ]) -> mat[3, 3, ]: """ """ ... @overload -def neg(x: mat44) -> mat44f: +def neg(x: mat[4, 4, ]) -> mat[4, 4, ]: """ """