如何在我的机器上安装numpy/core/numeric.py文件；我想要isclose()函数

Question

我好像漏掉了什么基本的东西。

在GitHub上，似乎有一些额外的功能，特别是isclose()，可以在这里找到，但我安装的版本里没有这个功能。

我做了以下操作：

$ git clone git://github.com/numpy/numpy.git numpy

但是好像没有效果。

我还通过Synaptic Package Manager检查了更新，但也没有解决问题。我到底漏掉了什么？我该如何获得“最新”的版本呢？

我在Ubuntu 12.10上运行的是python 2.7.3。

Answer 1

要安装那个版本的numpy，你需要先进入你刚刚克隆下来的 numpy/ 目录。

然后运行下面的命令：

python setup.py install

这样就可以了。

Answer 2

你提到的代码是Joe Kington对numpy这个包的一个修改版本。

你发的git clone命令是用来把这个修改版本的源代码下载到你自己的电脑上。下载后，你还需要编译numpy并安装它，才能使用这个版本的numpy。

获取isclose这个功能最简单的方法就是把代码复制到一个文件里，然后导入它：

utils_num.py

import numpy as np
def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
    """
    https://github.com/joferkington/numpy/blob/3a85c0a9af64b0296b9a4c97f43f2f209c849077/numpy/core/numeric.py
    Returns a boolean array where two arrays are element-wise equal within a
    tolerance.

    The tolerance values are positive, typically very small numbers.  The
    relative difference (`rtol` * abs(`b`)) and the absolute difference
    `atol` are added together to compare against the absolute difference
    between `a` and `b`.

    Parameters
    ----------
    a, b : array_like
        Input arrays to compare.
    rtol : float
        The relative tolerance parameter (see Notes).
    atol : float
        The absolute tolerance parameter (see Notes).
    equal_nan : bool
        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
        considered equal to NaN's in `b` in the output array.

    Returns
    -------
    y : array_like
        Returns a boolean array of where `a` and `b` are equal within the
        given tolerance. If both `a` and `b` are scalars, returns a single
        boolean value.

    See Also
    --------
    allclose

    Notes
    -----
    For finite values, isclose uses the following equation to test whether
    two floating point values are equivalent.
     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
    The above equation is not symmetric in `a` and `b`, so that
    `isclose(a, b)` might be different from `isclose(b, a)` in
    some rare cases.

    Examples
    --------
    >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
    array([True, False])
    >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
    array([True, True])
    >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
    array([False, True])
    >>> np.isclose([1.0, np.nan], [1.0, np.nan])
    array([True, False])
    >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
    array([True, True])
    """
    def within_tol(x, y, atol, rtol):
        result = np.less_equal(abs(x - y), atol + rtol * abs(y))
        if np.isscalar(a) and np.isscalar(b):
            result = result[0]
        return result
    x = np.array(a, copy=False, ndmin=1)
    y = np.array(b, copy=False, ndmin=1)
    xfin = np.isfinite(x)
    yfin = np.isfinite(y)
    if np.all(xfin) and np.all(yfin):
        return within_tol(x, y, atol, rtol)
    else:
        # Avoid subtraction with infinite/nan values...
        cond = np.zeros(broadcast(x, y).shape, dtype=bool)
        mask = xfin & yfin
        cond[mask] = within_tol(x[mask], y[mask], atol, rtol)
        # Check for equality of infinite values...
        cond[~mask] = (x[~mask] == y[~mask])
        if equal_nan:
            # Make NaN == NaN
            cond[isnan(x) & isnan(y)] = True
        return cond

test.py:

import utils_num as UN
print(UN.isclose([1e10,1e-7], [1.00001e10,1e-8]))

这样就能得到

array([ True, False], dtype=bool)