GPU阵列#

向量类型#

class pycuda.gpuarray.vec#: 所有CUDA支持的向量类型，例如 float3 和 long4 可用作 numpy 此类中的数据类型。这些 numpy.dtype 实例的字段名为 x ， y ， z 和 w 就像他们的cuda对手一样。它们既可以用于参数传递到内核，也可以用于在内核和python代码之间来回传递数据。对于每种类型，a make_type 还提供了功能（例如 make_float3(x,y,z) ）

这个 `GPUArray` 数组类#

class pycuda.gpuarray.GPUArray(shape, dtype, *, allocator=None, order='C')#

A numpy.ndarray 存储数据并在计算设备上执行计算的类似工作。形状和 D型工作完全一样 numpy . 中的算术方法 GPUArray 支持标量的广播。（例如） array+5 如果

分配器 是一个可调用的，当调用一个要分配的字节数的参数时，返回一个可以被转换为一个对象的对象。 int 表示新分配内存的地址。注意两个 pycuda.driver.mem_alloc() 和 pycuda.tools.DeviceMemoryPool.alloc() 是这个接口的一个模型。

除此之外的所有论据 分配器 只应视为关键字。

gpudata#: 这个 pycuda.driver.DeviceAllocation 为支持此操作的内存创建的实例 GPUArray .

shape#: 数组中每个维度长度的元组。

dtype#: 这个 numpy.dtype GPU数组中的项。

size#: 数组中有意义的条目数。也可以通过乘以数字来计算。 shape .

mem_size#: 数组中存在的条目总数，包括填充。例如，由于通过 pycuda.driver.mem_alloc_pitch() .

nbytes#: 整个数组的大小（字节）。计算为 size 次 dtype.itemsize .

strides#: 遍历数组时要在每个维度中单步执行的字节元组。

flags#: 返回具有属性的对象 c_contiguous ， f_contiguous 和 forc ，可用于查询类似于 numpy.ndarray.flags .

ptr#: 返回一 int 反映此阵列所在的设备内存中的地址。

__cuda_array_interface__#: 返回一个 CUDA Array Interface 描述此数组数据的字典。

__len__()#: 返回的前导维度的大小 self .

警告

此方法存在于0.93及以下版本中，但它返回的值为 size 而不是它的当前值。为了匹配而做出了改变。 numpy .

reshape(shape, order='C')#: 返回包含具有新形状的相同数据的数组。

ravel()#: 返回包含相同数据的展平数组。

view(dtype=None)#: 返回具有相同数据的数组视图。如果 D型与当前数据类型不同，将重新解释内存的实际字节数。

squeeze(dtype=None)#: 返回已删除长度为1的数组的视图。

set(ary)#

将内容转移到 numpy.ndarray 对象 ary 在设备上。

ary 必须具有与 self .

set_async(ary, stream=None)#

异步传输内容 numpy.ndarray 对象 ary 在设备上，可以选择在流动 .

ary 必须具有与 self .

get(ary=None, pagelocked=False)#: 转移的内容 self 进入之内 ary 或新分配的 numpy.ndarray .如果 ary 给定时，它必须具有相同的形状和数据类型。如果没有提供，则 页面锁定 指定是否为新数组分配页锁定。

在 2015.2 版本发生变更: ary 不同的形状被弃用。

get_async(stream=None, ary=None)#: 转移的内容 self 进入之内 ary 或新分配的 numpy.ndarray .如果 ary 给定时，它必须具有正确的大小（不一定是形状）和数据类型。如果没有提供，则 page-locked 数组是新分配的。

copy()#: 在 2013.1 版本加入.

mul_add(self, selffac, other, otherfac, add_timer=None, stream=None):: 返回 selffac*self + otherfac*other . add_timer ，如果给定，则使用 pycuda.driver.Function.prepared_timed_call() .

__add__(other)#

__sub__(other)#

__iadd__(other)#

__isub__(other)#

__neg__(other)#

__mul__(other)#

__div__(other)#

__rdiv__(other)#

__pow__(other)#

__abs__()#: 返回A GPUArray 包含每个元素的绝对值 self .

fill(scalar, stream=None)#: 在数组中填充标量 .

astype(dtype, stream=None)#: 返回 self 铸成 D型 .

any(stream=None, allocator=None)#

all(stream=None, allocator=None)#

real#: 返回的实际部分 self 或 self 如果是真的。

在 0.94 版本加入.

imag#: 返回的虚部 self 或 zeros_like(self) 如果是真的。

conj(out=None)#: 返回的复共轭 self ，或 self 如果这是真的。如果 out 未给予，则新分配的 GPUArray 威尔回来了。使用 out=self 把共轭放在合适的位置。

在 2020.1.1 版本发生变更: 添加 out 参数

conjugate(out=None)#: 的别名 conj()

在 2020.1.1 版本加入.

bind_to_texref(texref, allow_offset=False)#

Bind self to the pycuda.driver.TextureReference texref.

由于对齐要求，有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法返回此偏移量，单位为 self 的数据类型。如果 allow_offset 是 False ，此偏移量的非零值将导致引发异常。

备注

建议使用 bind_to_texref_ext() 而不是这种方法。

bind_to_texref_ext(texref, channels=1, allow_double_hack=False, allow_offset=False)#

Bind self to the pycuda.driver.TextureReference texref. In addition, set the texture reference's format to match dtype and its channel count to channels. This routine also sets the texture reference's pycuda.driver.TRSF_READ_AS_INTEGER flag, if necessary.

在 0.93 版本加入.

在撰写本文时，CUDA纹理本身不支持双精度浮点数据。为了弥补这一缺陷，PycUDA包含一个解决方案，它可以通过 True 为了允许你的双重攻击。在这种情况下，请在内核代码中使用以下代码进行纹理访问：

#include <pycuda-helpers.hpp>

texture<fp_tex_double, 1, cudaReadModeElementType> my_tex;

__global__ void f()
{
  ...
  fp_tex1Dfetch(my_tex, threadIdx.x);
  ...
}

（此解决方案在版本0.94中添加）。

构造 `GPUArray` 实例#

pycuda.gpuarray.to_gpu(ary, allocator=None)#

返回A GPUArray 那是 numpy.ndarray 实例 ary .

见 GPUArray 为了…的意义 分配器 .

pycuda.gpuarray.to_gpu_async(ary, allocator=None, stream=None)#

返回A GPUArray 那是 numpy.ndarray 实例 ary . 复制是异步完成的，可以选择顺序为流动 .

见 GPUArray 为了…的意义 分配器 .

pycuda.gpuarray.empty(shape, dtype, *, allocator=None, order='C')#: 的同义词 GPUArray 建造师。

pycuda.gpuarray.zeros(shape, dtype=np.float64, *, allocator=None, order='C')#: 等同于 empty() 但是 GPUArray 在返回之前初始化为零。

pycuda.gpuarray.ones(shape, dtype=np.float64, *, allocator=None, order='C')#: 相同于 empty() ，但是 GPUArray 是1-在返回之前初始化。

pycuda.gpuarray.empty_like(other_ary, dtype=None, order='K')#: 创建新的、未初始化的 GPUArray 具有与 other_ary . 这个 D型和秩序属性允许这些方面独立于 other_ary . 为了秩序如果输入是Fortran连续的，则“A”表示保留Fortran顺序，否则使用“C”顺序。默认情况下，秩序或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.zeros_like(other_ary, dtype=None, order='K')#: 创建一个新的、初始化为零的 GPUArray 具有与 other_ary . 这个 D型和秩序属性允许这些方面独立于 other_ary . 为了秩序如果输入是Fortran连续的，则“A”表示保留Fortran顺序，否则使用“C”顺序。默认情况下，秩序或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.ones_like(other_ary, dtype=None, order='K')#: 创建一个新的，已初始化的 GPUArray 具有与 other_ary . 这个 D型和秩序属性允许这些方面独立于 other_ary . 为了秩序如果输入是Fortran连续的，则“A”表示保留Fortran顺序，否则使用“C”顺序。默认情况下，秩序或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.arange(start, stop, step, dtype=None, stream=None)#

创建一个 GPUArray 填充数字间隔 step 分开，从 start 结束于 stop .

对于浮点参数，结果的长度为 ceil((stop - start)/step) . 此规则可能导致结果的最后一个元素大于 stop .

D型，如果未指定，则被视为开始， stop 和 step .

pycuda.gpuarray.take(a, indices, stream=None)#: 返回 GPUArray [a[indices[0]], ..., a[indices[n]]] . 就目前而言， a 必须是可以绑定到纹理的类型。

pycuda.gpuarray.concatenate(arrays, axis=0, allocator=None)#: 沿现有轴合并数组序列。

pycuda.gpuarray.stack(arrays, axis=0, allocator=None)#: 沿新的轴合并一系列数组。

pycuda.gpuarray.logical_and(x1, x2, /, out=None, * allocator=None)#: 返回的元素式逻辑AND值 x1 和 x2 。

pycuda.gpuarray.logical_or(x1, x2, /, out=None, * allocator=None)#: 返回的元素式逻辑或值 x1 和 x2 。

pycuda.gpuarray.logical_not(x, /, out=None, * allocator=None)#: 返回元素形式的逻辑NOT OF x 。

条件句#

pycuda.gpuarray.if_positive(criterion, then_, else_, out=None, stream=None)#: 返回类似于 then_ ，对于索引处的元素 i 包含 [then_[i]] 如果 [criterion[i]>0] ，否则 [else_[i]] . （在0.94中添加）

pycuda.gpuarray.maximum(a, b, out=None, stream=None)#: 返回元素的最大值 a 和 b . （在0.94中添加）

pycuda.gpuarray.minimum(a, b, out=None, stream=None)#: 返回元素的最小值 a 和 b . （在0.94中添加）

约简#

pycuda.gpuarray.sum(a, dtype=None, stream=None)#

pycuda.gpuarray.any(a, stream=None, allocator=None)#

pycuda.gpuarray.all(a, stream=None, allocator=None)#

pycuda.gpuarray.subset_sum(subset, a, dtype=None, stream=None)#: 在 2013.1 版本加入.

pycuda.gpuarray.dot(a, b, dtype=None, stream=None)#

pycuda.gpuarray.subset_dot(subset, a, b, dtype=None, stream=None)#

pycuda.gpuarray.max(a, stream=None)#

pycuda.gpuarray.min(a, stream=None)#

pycuda.gpuarray.subset_max(subset, a, stream=None)#

pycuda.gpuarray.subset_min(subset, a, stream=None)#

上的元素级函数 `GPUArray` 实例#

这个 pycuda.cumath 模块包含包含 math .

舍入和绝对值#

pycuda.cumath.fabs(array, *, out=None, stream=None)#

pycuda.cumath.ceil(array, *, out=None, stream=None)#

pycuda.cumath.floor(array, *, out=None, stream=None)#

指数、对数和根#

pycuda.cumath.exp(array, *, out=None, stream=None)#

pycuda.cumath.log(array, *, out=None, stream=None)#

pycuda.cumath.log10(array, *, out=None, stream=None)#

pycuda.cumath.sqrt(array, *, out=None, stream=None)#

三角函数#

pycuda.cumath.sin(array, *, out=None, stream=None)#

pycuda.cumath.cos(array, *, out=None, stream=None)#

pycuda.cumath.tan(array, *, out=None, stream=None)#

pycuda.cumath.asin(array, *, out=None, stream=None)#

pycuda.cumath.acos(array, *, out=None, stream=None)#

pycuda.cumath.atan(array, *, out=None, stream=None)#

双曲函数#

pycuda.cumath.sinh(array, *, out=None, stream=None)#

pycuda.cumath.cosh(array, *, out=None, stream=None)#

pycuda.cumath.tanh(array, *, out=None, stream=None)#

浮点分解与汇编#

pycuda.cumath.fmod(arg, mod, stream=None)#: 返回除法的浮点余数 arg/mod ，对于中的每个元素 arg 和 mod .

pycuda.cumath.frexp(arg, stream=None)#: 返回元组 (significands, exponents) 这样的话 arg == significand * 2**exponent .

pycuda.cumath.ldexp(significand, exponent, stream=None)#: 返回一个新的浮点值数组，该数组由 significand 和 exponent ，配对为 result = significand * 2**exponent .

pycuda.cumath.modf(arg, stream=None)#: 返回元组 (fracpart, intpart) 包含 arg .

生成随机数数组#

pycuda.curandom.rand(shape, dtype=numpy.float32, stream=None)#: 返回一个数组 shape 填充随机值 dtype 在[0,1]范围内。

备注

这个函数的用例是“我需要一些随机数。它使用了一个非常糟糕的基于md5的生成器，甚至不尝试缓存生成的代码。

如果您对非玩具随机数生成器感兴趣，请使用下面基于curand的功能。

警告

以下类使用在GPU上运行的随机数生成器。每个线程都使用自己的生成器。创建这些生成器比随后生成的随机数需要更多的资源。在实验之后，特斯拉设备上的最大活动发电机数量（计算能力为1.x）看起来是256个。费米装置允许创建1024个发电机没有任何问题。如果创建类pseudorandomNumberGenerator或quasirandomNumberGenerator的对象时出现问题，请减少创建的生成器的数量（从而减少活动线程的数量）。

伪随机数列满足真正随机数列的大多数统计特性，但由确定性算法生成。利用均匀填充n维空间的确定性算法生成n维点的拟irandom序列。

类星体数字的生成成本更高。

pycuda.curandom.get_curand_version()#: 获取PyCUDA编译的Curand版本。返回3元组整数作为 （主要、次要、修订） .

pycuda.curandom.seed_getter_uniform(N)#: 返回一 GPUArray 充满一个随机的 int32 重复的 N 可以用作XOWOW发生器的种子的时间。

pycuda.curandom.seed_getter_unique(N)#: 返回一 GPUArray 充满 N 随机的 int32 可以作为XOWOW发生器的种子使用。

class pycuda.curandom.XORWOWRandomNumberGenerator(seed_getter=None, offset=0)#

参数:

seed_getter -- 一个给定整数计数的函数，它将产生一个 int32 GPUArray 种子的
offset -- 给定种子，开始索引到xorwow序列。

提供伪随机数。生成至少包含周期的序列 \(2^190\) .

CUDA 3.2及以上。

在 2011.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed pseudorandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed pseudorandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

在 2012.2 版本加入.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#

创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

CUDA 4.0及以上。

在 2012.2 版本加入.

fill_poisson(data, lambda_value=None, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

call_skip_ahead_sequence(i, stream=None)#: 强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果，但要快得多。

call_skip_ahead_sequence_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少子序列。

class pycuda.curandom.MRG32k3aRandomNumberGenerator(seed_getter=None, offset=0)#

参数:

seed_getter -- 一个给定整数计数的函数，它将产生一个 int32 GPUArray 种子的
offset -- 给定种子，开始索引到xorwow序列。

提供伪随机数。生成至少包含周期的序列 \(2^190\) .

CUDA 4.1及以上。

在 2013.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed pseudorandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed pseudorandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#: Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

fill_poisson(data, lambda_value, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

call_skip_ahead_sequence(i, stream=None)#: 强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果，但要快得多。

call_skip_ahead_sequence_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少子序列。

pycuda.curandom.generate_direction_vectors(count, direction=direction_vector_set.VECTOR_32)#: 返回一 GPUArray count 填充用于初始化sobol生成器的方向向量。

pycuda.curandom.generate_scramble_constants32(count)#: 返回A GPUArray 充满 count' 32-bit unsigned integer numbers used to initialize :class: 加扰双簧管32和数字发电机`

pycuda.curandom.generate_scramble_constants64(count)#: 返回A GPUArray 充满 count' 64-bit unsigned integer numbers used to initialize :class: 随机数发生器`

class pycuda.curandom.Sobol32RandomNumberGenerator(dir_vector=None, offset=0)#

参数:

dir_vector -- 一 GPUArray 共32个元素 int32 用于初始化类irandom生成器的向量；每个初始化生成器必须包含一个向量
offset -- 开始索引到sobol32序列，给定方向向量。

提供类irandom数。生成周期为的序列 \(2^32\) .

CUDA 3.2及以上。

在 2011.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

在 2012.2 版本加入.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#

创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

CUDA 4.0及以上。

在 2012.2 版本加入.

fill_poisson(data, lambda_value, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

class pycuda.curandom.ScrambledSobol32RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)#

参数:

dir_vector -- 一 GPUArray 共32个元素 uint32 用于初始化类irandom生成器的向量；每个初始化生成器必须包含一个向量
scramble_vector -- 一 GPUArray 属于 uint32 用于初始化Quasirandom生成器的元素；每个初始化生成器必须包含一个数字
offset -- 开始索引到sobol32序列，给定方向向量。

提供类irandom数。生成周期为的序列 \(2^32\) .

CUDA 4.0及以上。

在 2011.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

在 2012.2 版本加入.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#

创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

CUDA 4.0及以上。

在 2012.2 版本加入.

fill_poisson(data, lambda_value, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

class pycuda.curandom.Sobol64RandomNumberGenerator(dir_vector=None, offset=0)#

参数:

dir_vector -- 一 GPUArray 共64个元素 uint64 用于初始化类irandom生成器的向量；每个初始化生成器必须包含一个向量
offset -- 给定方向向量，开始索引到sobol64序列。

提供类irandom数。生成周期为的序列 \(2^64\) .

CUDA 4.0及以上。

在 2011.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

在 2012.2 版本加入.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#

创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

CUDA 4.0及以上。

在 2012.2 版本加入.

fill_poisson(data, lambda_value, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

class pycuda.curandom.ScrambledSobol64RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)#

参数:

dir_vector -- 一 GPUArray 共64个元素 uint64 用于初始化类irandom生成器的向量；每个初始化生成器必须包含一个向量
scramble_vector -- 一 GPUArray 属于 uint64 用于初始化类irandom生成器的向量；每个初始化生成器必须包含一个向量
offset -- 在给定方向向量的情况下，开始索引到加扰双簧管64序列。

提供类irandom数。生成周期为的序列 \(2^64\) .

CUDA 4.0及以上。

在 2011.1 版本加入.

fill_uniform(data, stream=None)#: Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用均匀分布的伪随机值填充它，并返回新创建的对象。

fill_normal(data, stream=None)#: Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)#: 创建对象 GPUArray 给予形状和 D型，用正态分布的伪随机值填充它，并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)#

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

在 2012.2 版本加入.

gen_log_normal(shape, dtype, mean, stddev, stream=None)#

创建对象 GPUArray 给予形状和 D型，用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ，并返回新创建的对象。

CUDA 4.0及以上。

在 2012.2 版本加入.

fill_poisson(data, lambda_value, stream=None)#

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无，而是用作lambda，并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”，则从每个 data 数组元素（类似于numpy.random.poisson)，数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

在 2013.1 版本加入.

gen_poisson(shape, dtype, lambda_value, stream=None)#

创建对象 GPUArray 给予形状和 D型，用poisson分布的伪随机值填充 lambda_value ，并返回新创建的对象。 D型必须是32位无符号整数。

CUDA 5.0及以上。

在 2013.1 版本加入.

call_skip_ahead(i, stream=None)#: 强制所有生成器跳过i值。相当于生成i值并丢弃结果，但速度要快得多。

call_skip_ahead_array(i, stream=None)#: 接受整数值数组i，告诉每个生成器要跳过多少个值。

单程自定义表达式求值#

计算上涉及的表达式 GPUArray 实例可能有点低效，因为为每个中间结果创建了一个新的临时。模块中的功能 pycuda.elementwise 包含有助于生成内核的工具，这些内核在一次传递中对一个或多个操作数计算多级表达式。

class pycuda.elementwise.ElementwiseKernel(arguments, operation, name='kernel', keep=False, options=[], preamble='')#

生成一个核，该核接受多个标量或向量参数并执行标量操作在其参数的每个条目上，如果该参数是向量。

参数指定为格式化为C参数列表的字符串。操作指定为C赋值语句，不带分号。向量在操作应该由变量索引 i .

name 指定编译内核的名称， keep 和选项未经修改传递给 pycuda.compiler.SourceModule .

序言指定在ElementWise内核规范之前包含的一些源代码。您可以使用它来包含其他文件和/或定义操作 .

__call__(*args, range=None, slice=None)#

调用生成的标量内核。参数可以是标量或 GPUArray 实例。

如果范围是的，一定是 slice 对象并指定索引的范围。 i 为此操作执行。

如果片是的，一定是 slice 对象并指定索引的范围。 i 为此操作执行，截断到容器。也，片可能包含相对于数组结尾的负索引。

如果流动是的，一定是 pycuda.driver.Stream 对象，执行将在其中序列化。

下面是一个用法示例：

import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
import pycuda.autoinit
import numpy
from pycuda.curandom import rand as curand

a_gpu = curand((50,))
b_gpu = curand((50,))

from pycuda.elementwise import ElementwiseKernel
lin_comb = ElementwiseKernel(
        "float a, float *x, float b, float *y, float *z",
        "z[i] = a*x[i] + b*y[i]",
        "linear_combination")

c_gpu = gpuarray.empty_like(a_gpu)
lin_comb(5, a_gpu, 6, b_gpu, c_gpu)

import numpy.linalg as la
assert la.norm((c_gpu - (5*a_gpu+6*b_gpu)).get()) < 1e-5

（你可以找到这个例子 examples/demo_elementwise.py 在Pycuda分布中。）

自定义缩减#

class pycuda.reduction.ReductionKernel(dtype_out, neutral, reduce_expr, map_expr=None, arguments=None, name='reduce_kernel', keep=False, options=[], preamble='', allocator=None)#

生成一个核，该核接受多个标量或向量参数（至少一个向量参数），执行 map_expr 在向量参数的每个条目上，然后 reduce_expr 关于结果。 中立的 作为初始值。序言提供了在实际的缩减内核代码之前添加预处理器指令和其他代码（如助手函数）的可能性。

向量在 map_expr 应该由变量索引 i . reduce_expr 使用形式值“a”和“b”指示二进制缩减操作的两个操作数。如果未指定 map_expr ，“在 [i] “——因此只存在一个输入参数——是自动假定的。 reduce_expr 必须是关联的。

dtype_out 指定 numpy.dtype 其中执行缩减并返回结果。 中立的 指定为浮点或格式为字符串的整数。 reduce_expr 和 map_expr 指定为字符串格式的操作和参数指定为格式化为C参数列表的字符串。 name 指定编译内核的名称， keep 和选项未经修改传递给 pycuda.compiler.SourceModule . 序言指定为代码字符串。

__call__(*args, stream=None, out=None)#

调用生成的缩减内核。参数可以是标量，也可以是 GPUArray 实例。将对第一个向量参数的每个条目进行缩减。

如果流动是的，一定是 pycuda.driver.Stream 对象，执行将在其中序列化。

用 out 生成的单个条目 GPUArray 可以指定。因为支持偏移，所以可以在任何地方存储结果（例如out=a [3] ）

下面是一个用法示例：

a = gpuarray.arange(400, dtype=numpy.float32)
b = gpuarray.arange(400, dtype=numpy.float32)

krnl = ReductionKernel(numpy.float32, neutral="0",
        reduce_expr="a+b", map_expr="x[i]*y[i]",
        arguments="float *x, float *y")

my_dot_prod = krnl(a, b).get()

或通过指定输出：

from pycuda.curandom import rand as curand
a = curand((10, 200), dtype=np.float32)
red = ReductionKernel(np.float32, neutral=0,
                           reduce_expr="a+b",
                           arguments="float *in")
a_sum = gpuarray.empty(10, dtype=np.float32)
for i in range(10):
    red(a[i], out=a_sum[i])
assert(np.allclose(a_sum.get(), a.get().sum(axis=1)))

并行扫描/前缀和#

class pycuda.scan.ExclusiveScanKernel(dtype, scan_expr, neutral, name_prefix='scan', options=[], preamble='')#

生成一个可以计算 prefix sum 使用任何关联操作 scan_expr . scan_expr 使用形式值“a”和“b”指示关联二进制运算的两个操作数。 中立的 是中性元素 scan_expr 服从 scan_expr(a, neutral) == a .

D型指定要操作的数组的类型。 name_prefix 用于内核名称，以确保配置文件和日志中的可识别性。选项是生成时要使用的编译器选项的列表。序言指定在实际内核之前插入的代码字符串。

__call__(self, input_ary, output_ary=None, allocator=None, queue=None)#

class pycuda.scan.InclusiveScanKernel(dtype, scan_expr, neutral=None, name_prefix='scan', options=[], preamble='', devices=None)#: 作品像 ExclusiveScanKernel . 与独家案件不同， 中立的 不是必需的。

下面是一个用法示例：

knl = InclusiveScanKernel(np.int32, "a+b")

n = 2**20-2**18+5
host_data = np.random.randint(0, 10, n).astype(np.int32)
dev_data = gpuarray.to_gpu(queue, host_data)

knl(dev_data)
assert (dev_data.get() == np.cumsum(host_data, axis=0)).all()

缩小和扫描中的自定义数据类型#

如果要在扫描和缩减中使用自己的（struct/union/whatever）数据类型，请在序言使用此函数让pycuda知道它们：

pycuda.tools.register_dtype(dtype, name)#: D型是一个 numpy.dtype() .

gpgpu算法#

博格丹奥潘丘克 reikna 提供了多种基于gpu的算法（fft、rng、矩阵乘法），可用于 pycuda.gpuarray.GPUArray 物体。

GPU阵列#

向量类型#

这个 GPUArray 数组类#

构造 GPUArray 实例#

条件句#

约简#

上的元素级函数 GPUArray 实例#

舍入和绝对值#

指数、对数和根#

三角函数#

双曲函数#

浮点分解与汇编#

生成随机数数组#

单程自定义表达式求值#

自定义缩减#

并行扫描/前缀和#

缩小和扫描中的自定义数据类型#

gpgpu算法#

这个 `GPUArray` 数组类#

构造 `GPUArray` 实例#

上的元素级函数 `GPUArray` 实例#