将 numpy 数组的实部和虚部元素四舍五入，向零或远离零四舍​​五入

Question

我有一个 numpy 复数数组，需要创建一个包含四舍五入实部和虚部的新数组，其中一半的舍入要么接近零，要么远离零。

在stackoverflow 上有几项使用decimal 包的建议，允许指定不同类型的舍入。对于复数数组x，以下代码可以工作，但速度很慢：

    rounded_array = np.array([
        float(Decimal(x.real).quantize(0, rounding=ROUND_HALF_DOWN)) + 1j * \
        float(Decimal(x.imag).quantize(0, rounding=ROUND_HALF_DOWNs)) for x in arr])

有哪些简单但更快的替代方法？

ROUND_HALF_UP 和 ROUND_HALF_DOWN 的确切含义如下所示：https://docs.python.org/3/library/decimal.html#decimal.ROUND_HALF_UP。

非常清楚，对于从零舍入或向零舍入，例如复数的实部，我寻求（注意两半的差异）

      toward zero(ROUND_HALF_DOWN) away from zero (ROUND_HALF_UP)
-4.00         -4.0                 -4.0
-3.75         -4.0                 -4.0
-3.50         -3.0                 -4.0
-3.25         -3.0                 -3.0
-3.00         -3.0                 -3.0
-2.75         -3.0                 -3.0
-2.50         -2.0                 -3.0
-2.25         -2.0                 -2.0
-2.00         -2.0                 -2.0
-1.75         -2.0                 -2.0
-1.50         -1.0                 -2.0
-1.25         -1.0                 -1.0
-1.00         -1.0                 -1.0
-0.75         -1.0                 -1.0
-0.50         -0.0                 -1.0
-0.25         -0.0                 -0.0
 0.00          0.0                  0.0
 0.25          0.0                  0.0
 0.50          0.0                  1.0
 0.75          1.0                  1.0
 1.00          1.0                  1.0
 1.25          1.0                  1.0
 1.50          1.0                  2.0
 1.75          2.0                  2.0
 2.00          2.0                  2.0
 2.25          2.0                  2.0
 2.50          2.0                  3.0
 2.75          3.0                  3.0
 3.00          3.0                  3.0
 3.25          3.0                  3.0
 3.50          3.0                  4.0
 3.75          4.0                  4.0
 4.00          4.0                  4.0

How to always round up a XX.5 in numpy 的公认解决方案既慢又不提供我感兴趣的舍入类型。

Answer 1

linked answer 背后的想法 是合理的，但 np.vectorize 并没有真正矢量化任何东西。让我们看一下ROUND_HALF_DOWN，它向零舍入。这意味着对于x >= 0，您想要获得ceil(x - 0.5)。对于x < 0，你想做floor(x + 0.5)。这可以使用矢量化操作来完成，例如

mask = (x >= 0)
output = x.copy()
np.add(output, -0.5, where=mask, out=output)
np.add(output, 0.5, where=~mask, out=output)
np.ceil(output, where=mask, out=output)
np.floor(output, where=~mask, out=output)

更占用空间，但不那么冗长：

mask = (x >= 0)
output = np.empty_like(x)
output[mask] = np.ceil(x[mask] - 0.5)
output[~mask] = np.floor(x[~mask] + 0.5)

要就地执行操作，只需对x 进行操作，而不是output。第二部分是分别处理数组的实部和虚部。对于连续数组，这可以通过视图轻松完成，例如：

x = x.view(np.float)

你可以转换回来

x = x.view(np.complex)

如果您的数组不连续，最好的办法是分别处理实部和虚部。 x.real 和 x.imag 是数据视图，因此您可以就地操作它。

TL;DR

def round_half_down(arr):
    output = arr.copy().view(np.float)   # This won't fail because the copy is contiguous
    mask = (output >= 0)
    np.subtract(output, 0.5, where=mask, out=output)
    np.ceil(output, where=mask, out=output)
    np.invert(mask, out=mask)
    np.add(output, 0.5, where=mask, out=output)
    np.floor(output, where=mask, out=output)
    return output.view(np.complex)