python - 将 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 .第二部分分别处理数组的实部和虚部。对于连续数组，这很容易通过 View 完成，例如:

x = x.view(np.float)

你可以转换回来

x = x.view(np.complex)

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

长话短说

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)