内核参考#
标量类型#
向量类型#
泛型类型#
- class warp.Int#
- class warp.Float#
- class warp.Scalar#
- class warp.Vector#
- class warp.Matrix#
- class warp.Quaternion#
- class warp.Transformation#
- class warp.Array#
标量数学#
- warp.round(x: Float) Float#
返回最接近
x的整数值，将小数部分为 0.5 的情况四舍五入到远离零的方向。这是口语中最直观的四舍五入形式，但可能比
warp.rint()等其他选项慢。与numpy.round()不同，后者与numpy.rint()的行为相同。
- warp.rint(x: Float) Float#
返回最接近
x的整数值，将小数部分为 0.5 的情况四舍五入到最接近的偶数。通常比
warp.round()更快。等同于numpy.rint()。
- warp.trunc(x: Float) Float#
返回比
x更接近零的最近整数。换句话说，它丢弃
x的小数部分。它类似于将float(int(a))强制转换，但在x在 [-0.0, -1.0) 范围内时保留负号。等同于numpy.trunc()和numpy.fix()。
- warp.isfinite(a: Quaternion[Scalar]) bool
如果四元数
a的所有元素都是有限的则返回True，否则返回False。
- warp.isnan(a: Quaternion[Scalar]) bool
如果四元数
a的任一元素是 NaN 则返回True，否则返回False。
- warp.isinf(a: Quaternion[Scalar]) bool
如果四元数
a的任一元素是正无穷或负无穷则返回True，否则返回False。
向量数学#
- warp.dot(a: Quaternion[Float], b: Quaternion[Float]) Float
计算两个四元数的点积。
- warp.length(a: Quaternion[Float]) Float
计算四元数
a的长度。
- warp.length_sq(a: Quaternion[Scalar]) Scalar
计算四元数
a的平方长度。
- warp.normalize(a: Quaternion[Float]) Quaternion[Float]
计算
a的归一化值。如果length(a)为 0，则返回零四元数。
- warp.matrix( ) Matrix[4, 4, Float]#
构建一个 4x4 变换矩阵，该矩阵在应用于列向量时，按照 Translation(pos)*Rotation(rot)*Scaling(scale) 的顺序应用变换，即：y = (TRS)*x
- warp.identity(n: int32, dtype: Scalar) Matrix[Any, Any, Scalar]#
创建一个 shape=(n,n) 的单位矩阵，其类型由
dtype指定。
- warp.math.norm_l1(v)#
计算向量 v 的 L1 范数。
\[\|v\|_1 = \sum_i |v_i|\]
- warp.math.norm_l2(v)#
计算向量 v 的 L2 范数。
\[\|v\|_2 = \sqrt{\sum_i v_i^2}\]
- warp.math.norm_huber(v, delta=1.0)#
计算向量 v 在给定 delta 下的 Huber 范数。
\[\begin{split}H(v) = \begin{cases} \frac{1}{2} \|v\|^2 & \text{if } \|v\| \leq \delta \\ \delta(\|v\| - \frac{1}{2}\delta) & \text{otherwise} \end{cases}\end{split}\]
- warp.math.norm_pseudo_huber(v, delta=1.0)#
计算向量 v 在给定 delta 下的“伪”Huber 范数。
\[H^\prime(v) = \delta \sqrt{1 + \frac{\|v\|^2}{\delta^2}}\]
四元数数学#
- warp.quaternion(dtype: Float) Quaternion[Float]#
构造一个零初始化的四元数。四元数按 [ix, iy, iz, r] 排布，其中 ix, iy, iz 是虚部，r 是实部。
- warp.quaternion( ) Quaternion[Float]
使用提供的分量创建四元数（类型从分量类型推断）。
- warp.quaternion( ) Quaternion[Float]
使用提供的向量/标量创建四元数（类型从标量类型推断）。
- warp.quaternion(quat: Quaternion[Float], dtype: Float) Quaternion[Float]
从另一个不同 dtype 的四元数构造一个 dtype 类型的四元数。
- warp.quat_from_axis_angle( ) Quaternion[Float]#
构造一个表示绕给定轴旋转 angle 弧度的四元数。
- warp.quat_to_axis_angle(
- quat: Quaternion[Float],
- axis: Vector[3, 3, Float],
- angle: Float,
提取四元数表示的旋转轴和弧度角。
- warp.quat_from_matrix(mat: Matrix[3, 3, Float]) Quaternion[Float]#
从 3x3 矩阵构造四元数。
如果矩阵不是纯旋转，而是例如包含缩放或剪切，则结果未定义。
- warp.quat_from_matrix(mat: Matrix[4, 4, Float]) Quaternion[Float]
从 4x4 矩阵构造四元数。
如果矩阵的左上角 3x3 块不是纯旋转，而是例如包含缩放或剪切，则结果未定义。
- warp.quat_rpy(roll: Float, pitch: Float, yaw: Float) Quaternion[Float]#
构造一个表示组合滚转 (z)、俯仰 (x)、偏航 (y) 弧度旋转的四元数。
- warp.quat_inverse(quat: Quaternion[Float]) Quaternion[Float]#
计算四元数共轭。
- warp.quat_rotate_inv(
- quat: Quaternion[Float],
- vec: Vector[3, Float],
使用四元数的逆旋转向量。
- warp.quat_slerp(
- a: Quaternion[Float],
- b: Quaternion[Float],
- t: Float,
在两个四元数之间进行球面线性插值。
- warp.quat_to_matrix(quat: Quaternion[Float]) Matrix[3, 3, Float]#
将四元数转换为 3x3 旋转矩阵。
变换#
- warp.transformation(
- pos: Vector[3, Float],
- rot: Quaternion[Float],
- dtype: Float,
构造一个刚体变换，其包含平移部分
pos和旋转rot。
- warp.transform_identity(dtype: Float) transformf#
构造一个单位变换，其平移为零，旋转为单位旋转。
- warp.transform_get_translation(
- xform: Transformation[Float],
返回变换
xform的平移部分。
- warp.transform_get_rotation(
- xform: Transformation[Float],
返回变换
xform的旋转部分。
- warp.transform_multiply(
- a: Transformation[Float],
- b: Transformation[Float],
将两个刚体变换相乘。
- warp.transform_point(
- xform: Transformation[Float],
- point: Vector[3, Float],
将变换应用于点
point，将齐次坐标视为 w=1（包含平移和旋转）。
- warp.transform_point( ) Vector[3, Float]
将变换应用于点
point，将齐次坐标视为 w=1。应用变换时将
point视为列向量，例如：y = mat*point。这与某些库（特别是 USD）不同，后者将变换应用于行向量，
y^T = point^T*mat^T。如果变换来自使用行向量的库，则用户在调用此方法之前应转置变换矩阵。
- warp.transform_vector(
- xform: Transformation[Float],
- vec: Vector[3, Float],
将变换应用于向量
vec，将齐次坐标视为 w=0（仅旋转）。
- warp.transform_vector( ) Vector[3, Float]
将变换应用于向量
vec，将齐次坐标视为 w=0。应用变换时将
vec视为列向量，例如：y = mat*vec。这与某些库（特别是 USD）不同，后者将变换应用于行向量，
y^T = vec^T*mat^T。如果变换来自使用行向量的库，则用户在调用此方法之前应转置变换矩阵。
- warp.transform_inverse(
- xform: Transformation[Float],
计算变换
xform的逆。
- warp.math.transform_from_matrix(mat)#
从 4x4 矩阵构造一个变换。
- 参数:
- 返回:
变换。
- 返回类型:
- warp.math.transform_to_matrix(xform)#
将变换转换为 4x4 矩阵。
- 参数:
xform (Transformation[Float]) – 要转换的变换。
- 返回:
矩阵。
- 返回类型:
空间数学#
Tile 原语#
- warp.tile_zeros(shape: Tuple[int, ...], dtype: Any, storage: str) Tile#
分配一个零初始化的 Tile。
- 参数:
shape – 输出 Tile 的形状
dtype – 输出 Tile 元素的 数据类型（默认为 float）
storage – Tile 的存储位置：
"register"（默认为寄存器）或"shared"（用于共享内存）。
- 返回:
一个具有指定形状和数据类型的零初始化 Tile [1]
- warp.tile_ones(shape: Tuple[int, ...], dtype: Any, storage: str) Tile#
分配一个一初始化的 Tile。
- 参数:
shape – 输出 Tile 的形状
dtype – 输出 Tile 元素的 数据类型
storage – Tile 的存储位置：
"register"（默认为寄存器）或"shared"（用于共享内存）。
- 返回:
一个具有指定形状和数据类型的一初始化 Tile [1]
- warp.tile_arange(*args: Scalar, dtype: Any, storage: str) Tile#
生成一个具有线性间隔元素的 Tile。
- 参数:
args –
可变长度的位置参数，解释为
(stop,)：生成从0到stop - 1的值(start, stop)：生成从start到stop - 1的值(start, stop, step)：以指定的步长生成从start到stop - 1的值
dtype – 输出 Tile 元素的 数据类型（可选，默认为：
float）storage – Tile 的存储位置：
"register"（默认为寄存器）或"shared"（用于共享内存）。
- 返回:
一个
shape=(n)的 Tile，其中包含指定数据类型的线性间隔元素 [1]
- warp.tile_load( ) Array[Scalar]#
从全局内存数组加载一个 Tile。
此方法将利用块中的所有线程协作地从全局内存加载一个 Tile。
- 参数:
a – 全局内存中的源数组
shape – 要加载的 Tile 的形状，必须与
a具有相同的维度数offset – 在源数组中开始读取的偏移量（可选）
storage – Tile 的存储位置：
"register"（默认为寄存器）或"shared"（用于共享内存）。
- 返回:
一个具有指定形状且数据类型与源数组相同的 Tile
- warp.tile_store(a: Array[Any], t: Tile, offset: Tuple[int, ...]) None#
将 Tile 存储到全局内存数组。
此方法将利用块中的所有线程协作地将 Tile 存储到全局内存。
- 参数:
a – 全局内存中的目标数组
t – 要存储数据的源 Tile，必须与目标数组具有相同的数据类型和维度数
offset – 目标数组中的偏移量（可选）
- warp.tile_atomic_add( ) Tile#
将一个 1D Tile 原子地添加到数组 a 中，每个元素都将原子更新。
- 参数:
a – 全局内存中的数组，应与输入 Tile 具有相同的
dtypet – 要添加到目标数组的源 Tile
offset – 目标数组中的偏移量（可选）
- 返回:
一个与源 Tile 具有相同维度和数据类型的 Tile，其中包含目标元素的原始值
- warp.tile_view( ) Tile#
返回给定 Tile [offset, offset+shape] 的切片，如果未指定 shape，则将从未指定的 offset 维度推断。
- 参数:
t – 从中提取子范围的输入 Tile
offset – 源 Tile 中的偏移量
shape – 返回切片的形状
- 返回:
一个 Tile，其维度由指定的 shape 或剩余的源 Tile 维度给出 [1]
- warp.tile_assign(dst: Tile, src: Tile, offset: Tuple[int, ...]) None#
将一个 tile 赋值给目标 tile 的一个子区域。
- 参数:
dst – 要赋值的目标 tile
src – 要从中读取值的源 tile
offset – 在目标 tile 中写入的偏移量
- warp.tile(x: Any) Tile#
从每个线程的内核值构造一个新的 tile。
此函数将使用标量内核代码计算的值转换为 tile 表示形式，以便输入到集体操作中。
如果输入值是标量，则生成的 tile 具有
shape=(block_dim,)。如果输入值是向量，则生成的 tile 具有
shape=(length(vector), block_dim)。
- 参数:
x – 每个线程的局部值，例如标量、向量或矩阵。
- 返回:
一个 tile，其第一个维度根据值类型长度而定，第二个维度等于
block_dim。
此示例展示如何从线程变量创建线性序列。
@wp.kernel def compute(): i = wp.tid() t = wp.tile(i*2) print(t) wp.launch(compute, dim=16, inputs=[], block_dim=16)
打印结果
[0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30] = tile(shape=(16), storage=register)
- warp.untile(a: Tile) Scalar#
将 tile 转换回每个线程的值。
此函数将块范围的 tile 转换回每个线程的值。
如果输入 tile 是 1D 的，则生成的值将是每个线程的标量。
如果输入 tile 是 2D 的，则生成的值将是每个线程长度为 M 的向量。
- 参数:
a – 维度为
shape=(M, block_dim)的 tile。- 返回:
每个线程一个值，数据类型与 tile 相同。
此示例展示如何从线程变量创建线性序列。
@wp.kernel def compute(): i = wp.tid() # create block-wide tile t = wp.tile(i)*2 # convert back to per-thread values s = wp.untile(t) print(s) wp.launch(compute, dim=16, inputs=[], block_dim=16)
打印结果
0 2 4 6 8 ...
- warp.tile_transpose(a: Tile) Tile#
转置 tile。
对于共享内存 tile，此操作将与输入 tile 别名。寄存器 tile 将首先传输到共享内存，然后进行转置。
- 参数:
a – 要转置的 tile，其维度为
shape=(M,N)。- 返回:
维度为
shape=(N,M)的 tile。
- warp.tile_broadcast(a: Tile, shape: Tuple[int, ...]) Tile#
广播 tile。
将输入 tile
a广播到目标 shape。广播遵循 NumPy 广播规则。- 参数:
a – 要广播的 tile。
shape – 广播到的 shape。
- 返回:
具有广播 shape 的 tile。
- warp.tile_sum(a: Tile) Tile#
使用块中的所有线程协作计算 tile 元素的总和。
- 参数:
a – 要计算总和的 tile。
- 返回:
一个包含总和的单元素 tile。
示例
@wp.kernel def compute(): t = wp.tile_ones(dtype=float, shape=(16, 16)) s = wp.tile_sum(t) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
打印结果
[256] = tile(shape=(1), storage=register)
- warp.tile_min(a: Tile) Tile#
使用块中的所有线程协作计算 tile 元素的最小值。
- 参数:
a – 要计算最小值的 tile。
- 返回:
一个包含最小值的单元素 tile。
示例
@wp.kernel def compute(): t = wp.tile_arange(64, 128) s = wp.tile_min(t) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
打印结果
[64] = tile(shape=(1), storage=register)
- warp.tile_max(a: Tile) Tile#
使用块中的所有线程协作计算 tile 元素的最大值。
- 参数:
a – 要计算最大值的 tile。
- 返回:
一个包含最大值的单元素 tile。
示例
@wp.kernel def compute(): t = wp.tile_arange(64, 128) s = wp.tile_max(t) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
打印结果
[127] = tile(shape=(1), storage=register)
- warp.tile_reduce(op: Callable, a: Tile) Tile#
在 tile 上应用自定义归约（reduction）运算符。
此函数使用提供的运算符在 tile 上协作执行归约。
- 参数:
op – 一个可调用函数，接受两个参数并返回一个参数，可以是用户函数或内置函数。
a – 输入 tile，运算符（或其重载之一）必须能够接受 tile 的数据类型。
- 返回:
一个单元素 tile，其数据类型与输入 tile 相同。
示例
@wp.kernel def factorial(): t = wp.tile_arange(1, 10, dtype=int) s = wp.tile_reduce(wp.mul, t) print(s) wp.launch_tiled(factorial, dim=[1], inputs=[], block_dim=16)
打印结果
[362880] = tile(shape=(1), storage=register)
- warp.tile_map(op: Callable, a: Tile) Tile#
在 tile 上应用一元函数。
此函数使用块中的所有线程协作地将一元函数应用于 tile 的每个元素。
- 参数:
op – 一个可调用函数，接受一个参数并返回一个参数，可以是用户函数或内置函数。
a – 输入 tile，运算符（或其重载之一）必须能够接受 tile 的数据类型。
- 返回:
一个 tile，其维度和数据类型与输入 tile 相同。
示例
@wp.kernel def compute(): t = wp.tile_arange(0.0, 1.0, 0.1, dtype=float) s = wp.tile_map(wp.sin, t) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)
打印结果
[0 0.0998334 0.198669 0.29552 0.389418 0.479426 0.564642 0.644218 0.717356 0.783327] = tile(shape=(10), storage=register)
- warp.tile_map(op: Callable, a: Tile, b: Tile) Tile
在 tile 上应用二元函数。
此函数使用块中的所有线程协作地将二元函数应用于 tile 的每个元素。两个输入 tile 必须具有相同的维度和数据类型。
- 参数:
op – 一个可调用函数，接受两个相同类型的参数并返回一个相同类型的参数，可以是用户函数或内置函数。
a – 第一个输入 tile，运算符（或其重载之一）必须能够接受 tile 的 dtype。
b – 第二个输入 tile，运算符（或其重载之一）必须能够接受 tile 的 dtype。
- 返回:
一个 tile，其维度和数据类型与输入 tile 相同。
示例
@wp.kernel def compute(): a = wp.tile_arange(0.0, 1.0, 0.1, dtype=float) b = wp.tile_ones(shape=10, dtype=float) s = wp.tile_map(wp.add, a, b) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)
打印结果
[1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9] = tile(shape=(10), storage=register)
- warp.tile_diag_add(a: Tile, d: Tile) Tile#
将一个方阵与表示为 1D tile 的对角矩阵“d”相加。
- warp.tile_matmul(a: Tile, b: Tile, out: Tile) Tile#
计算矩阵乘积并累加
out += a*b。- 支持的数据类型包括
fp16, fp32, fp64 (实数)
vec2h, vec2f, vec2d (复数)
所有输入和输出 tile 必须具有相同的数据类型。必要时，tile 数据将自动迁移到共享内存，并在可用时使用 TensorCore 操作。
- 参数:
a – 维度为
shape=(M, K)的 tile。b – 维度为
shape=(K, N)的 tile。out – 维度为
shape=(M, N)的 tile。
- warp.tile_matmul(a: Tile, b: Tile) Tile
计算矩阵乘积
out = a*b。- 支持的数据类型包括
fp16, fp32, fp64 (实数)
vec2h, vec2f, vec2d (复数)
两个输入 tile 必须具有相同的数据类型。必要时，tile 数据将自动迁移到共享内存，并在可用时使用 TensorCore 操作。
- 参数:
a – 维度为
shape=(M, K)的 tile。b – 维度为
shape=(K, N)的 tile。
- 返回:
维度为
shape=(M, N)的 tile。
- warp.tile_fft(inout: Tile) Tile#
计算 2D 数据 tile 沿第二维的正向 FFT。
此函数协作地就地计算数据 tile 的正向 FFT，将每行单独处理。
请注意，目前尚不支持计算伴随（adjoint）。
- 支持的数据类型包括
vec2f, vec2d
- 参数:
inout – 输入/输出 tile。
- warp.tile_ifft(inout: Tile) Tile#
计算 2D 数据 tile 沿第二维的逆向 FFT。
此函数协作地就地计算数据 tile 的逆向 FFT，将每行单独处理。
请注意，目前尚不支持计算伴随（adjoint）。
- 支持的数据类型包括
vec2f, vec2d
- 参数:
inout – 输入/输出 tile。
- warp.tile_cholesky(A: Tile) Tile#
计算矩阵 A 的 Cholesky 分解 L。L 是下三角矩阵，满足 LL^T = A。
请注意，目前尚不支持计算伴随（adjoint）。
- 支持的数据类型包括
float32
float64
- 参数:
A – 一个方形、对称正定矩阵。
- 返回 L:
一个方形、下三角矩阵，满足 LL^T = A。
实用工具#
- warp.mlp(
- weights: Array[float32],
- bias: Array[float32],
- activation: Callable,
- index: int32,
- x: Array[float32],
- out: Array[float32],
计算一个多层感知器 (MLP) 层，形式为：
out = act(weights*x + bias)。自 1.6 版本起已废弃：请改用tile 原语。
- 参数:
weights – 层的网络权重，维度为
(m, n)。bias – 一个数组，维度为
(n)。activation – 一个
wp.func函数，接受一个标量 float 作为输入并返回一个标量 float 作为输出。index – 要处理的批次项索引，通常每个线程处理批次中的一个项，此时 index 应为
wp.tid()。x – 特征矩阵，维度为
(n, b)。out – 网络输出，维度为
(m, b)。
- 注意:
与 PyTorch 等其他一些框架相比，特征矩阵和输出矩阵是转置的。所有矩阵都假定存储在展平的行主序内存布局中（NumPy 默认）。
- warp.reversed(range: range_t) range_t#
返回反转顺序的 range。
- warp.tid() int#
返回 1D 内核启动的当前线程索引。
请注意，这是线程的全局索引，范围为 [0, dim)，其中 dim 是传递给内核启动的参数。
用户定义的 Warp 函数中不能调用此函数。
- warp.tid() Tuple[int, int]
返回 2D 内核启动的当前线程索引。
使用
i,j = wp.tid()语法获取内核线程网格内的坐标。用户定义的 Warp 函数中不能调用此函数。
- warp.tid() Tuple[int, int, int]
返回 3D 内核启动的当前线程索引。
使用
i,j,k = wp.tid()语法获取内核线程网格内的坐标。用户定义的 Warp 函数中不能调用此函数。
- warp.tid() Tuple[int, int, int, int]
返回 4D 内核启动的当前线程索引。
使用
i,j,k,l = wp.tid()语法获取内核线程网格内的坐标。用户定义的 Warp 函数中不能调用此函数。
- warp.select(cond: bool, value_if_false: Any, value_if_true: Any) Any#
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: int8, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: uint8, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: int16, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: uint16, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: int32, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: uint32, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: int64, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(cond: uint64, value_if_false: Any, value_if_true: Any) Any
在两个参数中选择，如果
cond为False，则返回value_if_false，否则返回value_if_true。自 1.7 版本起已废弃：请改用
where()函数，其参数顺序更直观：where(cond, value_if_true, value_if_false)。
- warp.select(
- arr: Array[Any],
- value_if_false: Any,
- value_if_true: Any,
在两个参数之间进行选择，如果
arr为 null，则返回value_if_false，否则返回value_if_true。自 1.7 版本弃用: 改用
where()函数，它的参数顺序更直观：where(arr, value_if_true, value_if_false)。
- warp.where(cond: bool, value_if_true: Any, value_if_false: Any) Any#
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: int8, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: uint8, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: int16, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: uint16, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: int32, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: uint32, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: int64, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(cond: uint64, value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
cond为True，则返回value_if_true，否则返回value_if_false。
- warp.where(arr: Array[Any], value_if_true: Any, value_if_false: Any) Any
在两个参数之间进行选择，如果
arr不为 null，则返回value_if_true，否则返回value_if_false。
- warp.atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) Any
原子地将
value加到arr[i,j,k]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j,k,l]上并返回旧值。
- warp.atomic_add(arr: FabricArray[Any], i: Int, value: Any) Any
原子地将
value加到arr[i]上并返回旧值。
- warp.atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) Any
原子地将
value加到arr[i,j]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j,k]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j,k,l]上并返回旧值。
- warp.atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) Any
原子地将
value加到arr[i]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j,k]上并返回旧值。
- warp.atomic_add( ) Any
原子地将
value加到arr[i,j,k,l]上并返回旧值。
- warp.atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) Any
原子地从
arr[i,j,k]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j,k,l]中减去value并返回旧值。
- warp.atomic_sub(arr: FabricArray[Any], i: Int, value: Any) Any
原子地从
arr[i]中减去value并返回旧值。
- warp.atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) Any
原子地从
arr[i,j]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j,k]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j,k,l]中减去value并返回旧值。
- warp.atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) Any
原子地从
arr[i]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j,k]中减去value并返回旧值。
- warp.atomic_sub( ) Any
原子地从
arr[i,j,k,l]中减去value并返回旧值。
- warp.atomic_min(arr: Array[Any], i: Int, value: Any) Any#
计算
value和arr[i]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min(arr: Array[Any], i: Int, j: Int, value: Any) Any
计算
value和arr[i,j]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) Any
计算
value和arr[i,j,k]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j,k,l]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min(arr: FabricArray[Any], i: Int, value: Any) Any
计算
value和arr[i]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min(arr: FabricArray[Any], i: Int, j: Int, value: Any) Any
计算
value和arr[i,j]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j,k]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j,k,l]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min(arr: IndexedFabricArray[Any], i: Int, value: Any) Any
计算
value和arr[i]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j,k]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_min( ) Any
计算
value和arr[i,j,k,l]的最小值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: Array[Any], i: Int, value: Any) Any#
计算
value和arr[i]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: Array[Any], i: Int, j: Int, value: Any) Any
计算
value和arr[i,j]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) Any
计算
value和arr[i,j,k]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j,k,l]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: FabricArray[Any], i: Int, value: Any) Any
计算
value和arr[i]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: FabricArray[Any], i: Int, j: Int, value: Any) Any
计算
value和arr[i,j]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j,k]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j,k,l]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max(arr: IndexedFabricArray[Any], i: Int, value: Any) Any
计算
value和arr[i]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j,k]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.atomic_max( ) Any
计算
value和arr[i,j,k,l]的最大值，原子地更新数组，并返回旧值。该操作对于向量和矩阵而言仅在每个分量上是原子操作。
- warp.lerp(
- a: Quaternion[Float],
- b: Quaternion[Float],
- t: Float,
使用因子
t对两个值a和b进行线性插值，计算公式为a*(1-t) + b*t
- warp.lerp(
- a: Transformation[Float],
- b: Transformation[Float],
- t: Float,
使用因子
t对两个值a和b进行线性插值，计算公式为a*(1-t) + b*t
- warp.smoothstep(a: Float, b: Float, x: Float) Float#
使用因子
x在两个值a和b之间进行平滑插值，并在钳位后使用三次 Hermite 插值返回一个介于 0 和 1 之间的结果。
- warp.expect_near( ) None
如果
a和b的任何元素的大小差超过容差，则向标准输出打印错误。
- warp.expect_near(
- a: Quaternion[Float],
- b: Quaternion[Float],
- tolerance: Float,
如果
a和b的任何元素的大小差超过容差，则向标准输出打印错误。
- warp.expect_near( ) None
如果
a和b的任何元素的大小差超过容差，则向标准输出打印错误。
- warp.len(a: Quaternion[Scalar]) int
返回四元数中的元素数量。
- warp.len(a: Transformation[Float]) int
返回变换中的元素数量。
- warp.len(a: Tile) int
返回 tile 中的行数。
几何体#
- warp.bvh_query_aabb(id: uint64, low: vec3f, high: vec3f) bvh_query_t#
针对 BVH 对象构造一个轴对齐包围盒查询。
此查询可用于遍历 BVH 内的所有边界。
- 参数:
id – BVH 标识符
low – 包围盒在 BVH 空间中的下限
high – 包围盒在 BVH 空间中的上限
- warp.bvh_query_ray(id: uint64, start: vec3f, dir: vec3f) bvh_query_t#
针对 BVH 对象构造一个射线查询。
此查询可用于遍历与射线相交的所有边界。
- 参数:
id – BVH 标识符
start – 射线在 BVH 空间中的起点
dir – 射线在 BVH 空间中的方向
- warp.bvh_query_next(query: bvh_query_t, index: int32) bool#
移动到查询返回的下一个边界。当前边界的索引存储在
index中，如果没有更多重叠边界则返回False。
- warp.mesh_query_point( ) mesh_query_point_t#
计算具有标识符
id的Mesh上离给定空间point最近的点。使用额外的射线投射来确定点在内部还是外部，从而识别距离的符号。这种方法相对健壮，但会增加计算成本。有关其他符号确定方法，请参见下文。
- 参数:
id – 网格标识符
point – 要查询的空间中的点
max_dist – 距离大于此值的网格面不会被查询考虑
- warp.mesh_query_point_no_sign( ) mesh_query_point_t#
计算具有标识符
id的Mesh上离给定空间point最近的点。此方法不计算点的符号（内部/外部），因此比其他点查询方法更快。
- 参数:
id – 网格标识符
point – 要查询的空间中的点
max_dist – 距离大于此值的网格面不会被查询考虑
- warp.mesh_query_furthest_point_no_sign( ) mesh_query_point_t#
计算具有标识符 id 的网格上离给定空间点最远的点。
此方法不计算点的符号（内部/外部）。
- 参数:
id – 网格标识符
point – 要查询的空间中的点
min_dist – 距离小于此值的网格面不会被查询考虑
- warp.mesh_query_point_sign_normal( ) mesh_query_point_t#
计算具有标识符
id的Mesh上离给定空间point最近的点。使用角度加权伪法向量识别距离的符号（内部/外部）。这种符号确定方法对于条件良好、密闭且不自相交的网格是稳健的。它的计算速度也相对较快。
- 参数:
id – 网格标识符
point – 要查询的空间中的点
max_dist – 距离大于此值的网格面不会被查询考虑
epsilon – 在定位最小距离顶点/面/边时，将距离值视为相等的 epsilon，以平均边长的分数表示，也用于将最近点视为在边/顶点上，默认为 1e-3
- warp.mesh_query_point_sign_winding_number( ) mesh_query_point_t#
计算具有标识符
id的Mesh上离给定空间点最近的点。使用网格相对于查询点的缠绕数来识别符号。这种符号确定方法对于条件不佳的网格是稳健的，即使网格不密闭，也能提供平滑的符号近似。这种方法是所有符号确定网格方法中最稳健、最准确的，但也是最昂贵的。
注意
必须将
Mesh对象构建时设置support_winding_number=True，此方法才能返回正确结果。- 参数:
id – 网格标识符
point – 要查询的空间中的点
max_dist – 距离大于此值的网格面不会被查询考虑
accuracy – 使用利用二阶偶极子近似的快速缠绕数方法计算缠绕数的精度，默认为 2.0
threshold – 被视为在内部的缠绕数阈值，默认为 0.5
- warp.mesh_query_ray( ) mesh_query_ray_t#
计算与标识符为
id的Mesh最接近的射线命中点。- 参数:
id – 网格标识符
start – 射线的起始点
dir – 射线方向（应归一化）
max_t – 沿射线检查相交点的最大距离
- warp.mesh_query_aabb( ) mesh_query_aabb_t#
构造针对
Mesh的轴对齐包围盒查询。此查询可用于遍历体积内的所有三角形。
- 参数:
id – 网格标识符
low – 网格空间中包围盒的下界
high – 网格空间中包围盒的上界
- warp.mesh_query_aabb_next(query: mesh_query_aabb_t, index: int32) bool#
移动到与查询包围盒重叠的下一个三角形。
当前面的索引存储在
index中，如果没有更多重叠的三角形，则返回False。
- warp.hash_grid_query_next(query: hash_grid_query_t, index: int32) bool#
移动到哈希网格查询中的下一个点。
当前邻居的索引存储在
index中，如果没有更多邻居，则返回False。
- warp.hash_grid_point_id(id: uint64, index: int32) int#
返回
HashGrid中一个点的索引。这可用于重新排序线程，以便网格遍历以空间一致的顺序发生。
如果
HashGrid尚未保留，则返回 -1。
- warp.intersect_tri_tri( ) int#
使用 Moller 方法测试两个三角形 (v0, v1, v2) 和 (u0, u1, u2) 之间的相交性。
如果三角形相交，则返回 > 0。
体积#
- warp.volume_sample( ) Any#
在体积局部空间点
uvw处，采样由id给定的类型为 dtype 的体积。插值应为
warp.Volume.CLOSEST或wp.Volume.LINEAR。
- warp.volume_sample_grad( ) Any#
在体积局部空间点
uvw处，采样由id给定的体积及其梯度。插值应为
warp.Volume.CLOSEST或wp.Volume.LINEAR。
- warp.volume_lookup( ) Any#
返回坐标为
i、j、k的体素的值，适用于类型为 dtype 的体积。如果此索引处的体素不存在，此函数将返回背景值。
- warp.volume_sample_f(id: uint64, uvw: vec3f, sampling_mode: int32) float#
在体积局部空间点
uvw处，采样由id给定的体积。插值应为
warp.Volume.CLOSEST或wp.Volume.LINEAR。
- warp.volume_sample_grad_f( ) float#
在体积局部空间点
uvw处，采样由id给定的体积及其梯度。插值应为
warp.Volume.CLOSEST或wp.Volume.LINEAR。
- warp.volume_lookup_f(id: uint64, i: int32, j: int32, k: int32) float#
返回坐标为
i、j、k的体素的值。如果此索引处的体素不存在，此函数将返回背景值
- warp.volume_sample_v(id: uint64, uvw: vec3f, sampling_mode: int32) vec3f#
在体积局部空间点
uvw处，采样由id给定的向量体积。插值应为
warp.Volume.CLOSEST或wp.Volume.LINEAR。
- warp.volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) vec3f#
返回坐标为
i、j、k的体素的向量值。如果此索引处的体素不存在，此函数将返回背景值。
- warp.volume_lookup_i(id: uint64, i: int32, j: int32, k: int32) int#
返回坐标为
i、j、k的体素的int32值。如果此索引处的体素不存在，此函数将返回背景值。
- warp.volume_sample_index( ) Any#
在体积局部空间点
uvw处，采样由id给定的体积。已分配体素的值从
voxel_data数组中读取，background 用作不存在体素的值。插值应为warp.Volume.CLOSEST或wp.Volume.LINEAR。此函数适用于索引网格和经典体积。
- warp.volume_sample_grad_index( ) Any#
在体积局部空间点
uvw处，采样由id给定的体积及其梯度。已分配体素的值从
voxel_data数组中读取，background 用作不存在体素的值。插值应为warp.Volume.CLOSEST或wp.Volume.LINEAR。此函数适用于索引网格和经典体积。
随机数#
- warp.rand_init(seed: int32, offset: int32) uint32
根据用户定义的种子和偏移量初始化一个新的随机数生成器。
这个替代构造函数在并行程序中很有用，其中整个核函数应该共享一个种子，但每个线程应该生成不相关的数值。在这种情况下，用法应为
r = rand_init(seed, tid)
- warp.pnoise( ) float
3D 周期性 Perlin 风格噪声。
- warp.pnoise( ) float
4D 周期性 Perlin 风格噪声。
其他#
- warp.lower_bound( ) int
在排序数组
arr的范围 [arr_begin, arr_end) 中搜索大于或等于value的最接近元素。
运算符#
- warp.add(
- a: Quaternion[Scalar],
- b: Quaternion[Scalar],
- warp.add(
- a: Transformation[Scalar],
- b: Transformation[Scalar],
- warp.add(a: Tile, b: Tile) Tile
将两个 tile 的每个元素相加
- warp.sub(
- a: Quaternion[Scalar],
- b: Quaternion[Scalar],
- warp.sub(
- a: Transformation[Scalar],
- b: Transformation[Scalar],
- warp.sub(a: Tile, b: Tile) Tile
从 a 中减去 b 的每个元素
- warp.mul(a: Quaternion[Scalar], b: Scalar) Quaternion[Scalar]
- warp.mul(a: Scalar, b: Quaternion[Scalar]) Quaternion[Scalar]
- warp.mul(
- a: Quaternion[Scalar],
- b: Quaternion[Scalar],
- warp.mul(
- a: Transformation[Scalar],
- b: Transformation[Scalar],
- warp.mul(a: Transformation[Scalar], b: Scalar) Transformation[Scalar]
- warp.mul(a: Scalar, b: Transformation[Scalar]) Transformation[Scalar]
- warp.mul(x: Tile, y: Scalar) Tile
将 tile 的每个元素乘以一个标量
- warp.mul(x: Scalar, y: Tile) Tile
将 tile 的每个元素乘以一个标量
- warp.div(a: Quaternion[Scalar], b: Scalar) Quaternion[Scalar]
- warp.div(a: Scalar, b: Quaternion[Scalar]) Quaternion[Scalar]
- warp.pos(x: Quaternion[Scalar]) Quaternion[Scalar]
- warp.neg(x: Quaternion[Scalar]) Quaternion[Scalar]
- warp.neg(x: Tile) Tile
对tile中的每个元素取反
代码生成#
- warp.static(expr: Any) Any[source]#
评估一个静态 Python 表达式并将其替换为其结果。
更多详细信息请参阅代码生成指南。
内部表达式只能引用定义包含该表达式的 Warp 内核或函数的当前作用域中可用的变量，包括常量变量和在实现函数或内核的当前闭包中捕获的变量。表达式的返回类型必须是 Warp 函数、字符串或在 Warp 内核和函数中支持的类型（目前不包括 Warp 数组，因为它们无法在 Warp 内核中创建）。
脚注