def equal(x1, x2):
    """
    Return (x1 == x2) element-wise.
 
    Unlike `numpy.equal`,this comparison is performed by first
    stripping whitespace characters from the end of the string.  This
    behavior is provided for backward-compatibility with numarray.
 
    Parameters
    ----------
    x1,x2 : array_like of str or unicode
        Input arrays of the same shape.
 
    Returns
    -------
    out : ndarray or bool
        Output array of bools,or a single bool if x1 and x2 are scalars.
 
    See Also
    --------
    not_equal,greater_equal,less_equal,greater,less
    """
    return compare_chararrays(x1, x2, ''=='', True)

def not_equal(x1, x2):
    """
    Return (x1 != x2) element-wise.
 
    Unlike `numpy.not_equal`,or a single bool if x1 and x2 are scalars.
 
    See Also
    --------
    equal, ''!='', True)

def greater_equal(x1, x2):
    """
    Return (x1 >= x2) element-wise.
 
    Unlike `numpy.greater_equal`,this comparison is performed by
    first stripping whitespace characters from the end of the string.
    This behavior is provided for backward-compatibility with
    numarray.
 
    Parameters
    ----------
    x1,not_equal, ''>='', True)

def less_equal(x1, x2):
    """
    Return (x1 <= x2) element-wise.
 
    Unlike `numpy.less_equal`, ''<='', True)

def greater(x1, x2):
    """
    Return (x1 > x2) element-wise.
 
    Unlike `numpy.greater`, ''>'', True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, np.add, np.subtract, np.multiply, np.divide,
            np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
            np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
            np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
            np.logical_and, np.logical_or, np.logical_xor, np.maximum,
            np.minimum, np.mod
            ]
 
        # These functions still return NotImplemented. Will be fixed in
        # future.
        # bad = [np.greater,np.greater_equal,np.less,np.less_equal,np.not_equal]
 
        a = np.array(''1'')
        b = 1
        for f in binary_funcs:
            assert_raises(TypeError, f, a, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], dtype=object)
 
        with warnings.catch_warnings():
            warnings.filterwarnings(''always'', '''', FutureWarning)
            assert_warns(FutureWarning, np.equal, a)
            assert_warns(FutureWarning, np.not_equal, a)
 
        with warnings.catch_warnings():
            warnings.filterwarnings(''error'', FutureWarning)
            assert_raises(FutureWarning, a)
            assert_raises(FutureWarning, a)
            # And the other do not warn:
            with np.errstate(invalid=''ignore''):
                np.less(a, a)
                np.greater(a, a)
                np.less_equal(a, a)
                np.greater_equal(a, a)

def approx(a, b, fill_value=True, rtol=1e-5, atol=1e-8):
    """
    Returns true if all components of a and b are equal to given tolerances.
 
    If fill_value is True,masked values considered equal. Otherwise,
    masked values are considered unequal.  The relative error rtol should
    be positive and << 1.0 The absolute error atol comes into play for
    those elements of b that are very small or zero; it says how small a
    must be also.
 
    """
    m = mask_or(getmask(a), getmask(b))
    d1 = filled(a)
    d2 = filled(b)
    if d1.dtype.char == "O" or d2.dtype.char == "O":
        return np.equal(d1, d2).ravel()
    x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_)
    y = filled(masked_array(d2, 1).astype(float_)
    d = np.less_equal(umath.absolute(x - y), atol + rtol * umath.absolute(y))
    return d.ravel()

def points_in_front(self, points, inverted=False, ret_indices=False):
        ''''''
        Given an array of points,return the points which lie either on the
        plane or in the half-space in front of it (i.e. in the direction of
        the plane normal).
 
        points: An array of points.
        inverted: When `True`,invert the logic. Return the points that lie
          behind the plane instead.
        ret_indices: When `True`,return the indices instead of the points
          themselves.
 
        ''''''
        sign = self.sign(points)
 
        if inverted:
            mask = np.less_equal(sign, 0)
        else:
            mask = np.greater_equal(sign, 0)
 
        indices = np.flatnonzero(mask)
 
        return indices if ret_indices else points[indices]

def equal(x1, True)

def not_equal(x1, True)

def greater_equal(x1, True)

def less_equal(x1, True)

def greater(x1, True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], a)

def approx(a, atol + rtol * umath.absolute(y))
    return d.ravel()

def has_approx_support(m, m_hat, prob=0.01):
    """Returns 1 if model selection error is less than or equal to prob rate,
    0 else.
 
    NOTE: why does np.nonzero/np.flatnonzero create so much problems?
    """
    m_nz = np.flatnonzero(np.triu(m, 1))
    m_hat_nz = np.flatnonzero(np.triu(m_hat, 1))
 
    upper_diagonal_mask = np.flatnonzero(np.triu(np.ones(m.shape), 1))
    not_m_nz = np.setdiff1d(upper_diagonal_mask, m_nz)
 
    intersection = np.in1d(m_hat_nz, m_nz)  # true positives
    not_intersection = np.in1d(m_hat_nz, not_m_nz)  # false positives
 
    true_positive_rate = 0.0
    if len(m_nz):
        true_positive_rate = 1. * np.sum(intersection) / len(m_nz)
        true_negative_rate = 1. - true_positive_rate
 
    false_positive_rate = 0.0
    if len(not_m_nz):
        false_positive_rate = 1. * np.sum(not_intersection) / len(not_m_nz)
 
    return int(np.less_equal(true_negative_rate + false_positive_rate, prob))

def equal(x1, True)

def not_equal(x1, True)

def greater_equal(x1, True)

def less_equal(x1, True)

def greater(x1, True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], a)

def equal(x1, True)

def not_equal(x1, True)

def greater_equal(x1, True)

def less_equal(x1, True)

def greater(x1, True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], a)

def equal(x1, True)

def not_equal(x1, True)

def greater_equal(x1, True)

def less_equal(x1, True)

def greater(x1, True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], a)

def approx(a, atol + rtol * umath.absolute(y))
    return d.ravel()

def equal(x1, True)

def not_equal(x1, True)

def greater_equal(x1, True)

def less_equal(x1, True)

def greater(x1, True)

def test_NotImplemented_not_returned(self):
        # See gh-5964 and gh-2091. Some of these functions are not operator
        # related and were fixed for other reasons in the past.
        binary_funcs = [
            np.power, b)

def test_identity_equality_mismatch(self):
        a = np.array([np.nan], a)

def approx(a, atol + rtol * umath.absolute(y))
    return d.ravel()

def atmax(a,upperlimit,dimension=None,inclusive=1):
    """
   Returns the maximum value of a,along dimension,including only values greater
   than (or equal to,if inclusive=1) upperlimit.  If the limit is set to None,
   a limit larger than the max value in the array is used.
 
   Usage:   atmax(a,upperlimit,dimension=None,inclusive=1)
   """
    if inclusive:         upperfcn = N.less
    else:               upperfcn = N.less_equal
    if dimension == None:
        a = N.ravel(a)
        dimension = 0
    if upperlimit == None:
        upperlimit = N.maximum.reduce(N.ravel(a))+1
    smallest = N.minimum.reduce(N.ravel(a))
    ta = N.where(upperfcn(a,upperlimit),a,smallest)
    return N.maximum.reduce(ta,dimension)

def density_slice(rast, rel=np.less_equal, threshold=1000, nodata=-9999):
    ''''''
    Returns a density slice from a given raster. Arguments:
        rast        A gdal.Dataset or a NumPy array
        rel         A NumPy logic function; defaults to np.less_equal
        threshold   An integer number
    ''''''
    # Can accept either a gdal.Dataset or numpy.array instance
    if not isinstance(rast, np.ndarray):
        rastr = rast.ReadAsArray()
 
    else:
        rastr = rast.copy()
 
    if (len(rastr.shape) > 2 and min(rastr.shape) > 1):
        raise ValueError(''Expected a single-band raster array'')
 
    return np.logical_and(
        rel(rastr, np.ones(rast.shape) * threshold),
        np.not_equal(rastr, np.ones(rast.shape) * nodata)).astype(np.int0)