两个例子

Question

如果类型正确，提供输入数组作为numpy中的ufunc的可选输出参数通常是否安全？例如，我已经验证了以下工作：

>>> import numpy as np
>>> arr = np.array([1.2, 3.4, 4.5])
>>> np.floor(arr, arr)
array([ 1.,  3.,  4.])

数组类型必须与输出兼容或与输出相同（这是numpy.floor()的浮点数），否则会发生这种情况：

>>> arr2 = np.array([1, 3, 4], dtype = np.uint8)
>>> np.floor(arr2, arr2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ufunc 'floor' output (typecode 'e') could not be coerced to provided output parameter (typecode 'B') according to the casting rule ''same_kind''

所以给定一个正确类型的数组，通常是否可以安全地应用ufuncs？或floor()是一个例外情况？文档没有说清楚，以下两个线程也没有与问题相关：

Numpy modify array in place?
Numpy Ceil and Floor "out" Argument

修改

作为第一顺序的猜测，我认为它基于http://docs.scipy.org/doc/numpy/user/c-info.ufunc-tutorial.html的教程，经常但并不总是安全的。在计算过程中使用输出数组作为中间结果的临时持有者似乎没有任何限制。虽然floor()和ciel()之类的东西可能不需要临时存储，但更复杂的功能可能会。话虽如此，整个现有的图书馆可能会记住这一点。

Answer 1

numpy函数的out参数是写入结果的数组。使用out的主要优点是避免在不需要的情况下分配新内存。

使用在输入的同一数组上写函数的输出是否安全？没有一般的答案，这取决于功能的作用。

两个例子

以下是两个类似ufunc的函数示例：

In [1]: def plus_one(x, out=None):
   ...:     if out is None:
   ...:         out = np.zeros_like(x)
   ...: 
   ...:     for i in range(x.size):
   ...:         out[i] = x[i] + 1
   ...:     return out
   ...: 

In [2]: x = np.arange(5)

In [3]: x
Out[3]: array([0, 1, 2, 3, 4])

In [4]: y = plus_one(x)

In [5]: y
Out[5]: array([1, 2, 3, 4, 5])

In [6]: z = plus_one(x, x)

In [7]: z
Out[7]: array([1, 2, 3, 4, 5])

功能shift_one：

In [11]: def shift_one(x, out=None):
    ...:     if out is None:
    ...:         out = np.zeros_like(x)
    ...: 
    ...:     n = x.size
    ...:     for i in range(n):
    ...:         out[(i+1) % n] = x[i]
    ...:     return out
    ...: 

In [12]: x = np.arange(5)

In [13]: x
Out[13]: array([0, 1, 2, 3, 4])

In [14]: y = shift_one(x)

In [15]: y
Out[15]: array([4, 0, 1, 2, 3])

In [16]: z = shift_one(x, x)

In [17]: z
Out[17]: array([0, 0, 0, 0, 0])

对于函数plus_one，没有问题：当参数x和out是相同的数组时，获得预期的结果。但是，当参数x和out是相同的数组时，函数shift_one给出了令人惊讶的结果，因为数组

讨论

对于out[i] := some_operation(x[i])形式的函数，例如上面的plus_one，还有函数floor，ceil，sin，cos，tan，log，conj等，据我所知它是< strong> safe 使用参数输出在输入中写入结果。

对于采用“out [i]：= some_operation（x [i]，y [i]）”形式的两个输入参数的函数，它也是安全，例如numpy函数add，乘，减。

对于其他功能，它是逐个案例。如下图所示，矩阵乘法不安全：

In [18]: a = np.arange(4).reshape((2,2))

In [19]: a
Out[19]: 
array([[0, 1],
       [2, 3]])

In [20]: b = (np.arange(4) % 2).reshape((2,2))

In [21]: b
Out[21]: 
array([[0, 1],
       [0, 1]], dtype=int32)

In [22]: c = np.dot(a, b)

In [23]: c
Out[23]: 
array([[0, 1],
       [0, 5]])

In [24]: d = np.dot(a, b, out=a)

In [25]: d
Out[25]: 
array([[0, 1],
       [0, 3]])

最后评论：如果实现是多线程的，则不安全函数的结果甚至可能是不确定的，因为它取决于处理数组元素的顺序。

Numpy将输入数组作为`out`参数传递给ufunc

1 个答案:

两个例子

讨论