code: def in1d(ar1, ar2, assume_unique=False, invert=False):
      """
      Test whether each element of a 1-D array is also present in a second array.
  
      Returns a boolean array the same length as `ar1` that is True
      where an element of `ar1` is in `ar2` and False otherwise.
  
      We recommend using :func:`isin` instead of `in1d` for new code.
  
      Parameters
      ----------
      ar1 : (M,) array_like
          Input array.
      ar2 : array_like
          The values against which to test each value of `ar1`.
      assume_unique : bool, optional
          If True, the input arrays are both assumed to be unique, which
          can speed up the calculation.  Default is False.
      invert : bool, optional
          If True, the values in the returned array are inverted (that is,
          False where an element of `ar1` is in `ar2` and True otherwise).
          Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
          to (but is faster than) ``np.invert(in1d(a, b))``.
  
          .. versionadded:: 1.8.0
  
      Returns
      -------
      in1d : (M,) ndarray, bool
          The values `ar1[in1d]` are in `ar2`.
  
      See Also
      --------
      isin                  : Version of this function that preserves the
                              shape of ar1.
      numpy.lib.arraysetops : Module with a number of other functions for
                              performing set operations on arrays.
  
      Notes
      -----
      `in1d` can be considered as an element-wise function version of the
      python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
      equivalent to ``np.array([item in b for item in a])``.
      However, this idea fails if `ar2` is a set, or similar (non-sequence)
      container:  As ``ar2`` is converted to an array, in those cases
      ``asarray(ar2)`` is an object array rather than the expected array of
      contained values.
  
      .. versionadded:: 1.4.0
  
      Examples
      --------
      >>> test = np.array([0, 1, 2, 5, 0])
      >>> states = [0, 2]
      >>> mask = np.in1d(test, states)
      >>> mask
      array([ True, False,  True, False,  True])
      >>> test[mask]
      array([0, 2, 0])
      >>> mask = np.in1d(test, states, invert=True)
      >>> mask
      array([False,  True, False,  True, False])
      >>> test[mask]
      array([1, 5])
      """
      # Ravel both arrays, behavior for the first array could be different
      ar1 = np.asarray(ar1).ravel()
      ar2 = np.asarray(ar2).ravel()
  
      # Check if one of the arrays may contain arbitrary objects
      contains_object = ar1.dtype.hasobject or ar2.dtype.hasobject
  
      # This code is run when
      # a) the first condition is true, making the code significantly faster
      # b) the second condition is true (i.e. `ar1` or `ar2` may contain
      #    arbitrary objects), since then sorting is not guaranteed to work
      if len(ar2) < 10 * len(ar1) ** 0.145 or contains_object:
          if invert:
              mask = np.ones(len(ar1), dtype=bool)
              for a in ar2:
                  mask &= ar1 != a
          else:
              mask = np.zeros(len(ar1), dtype=bool)
              for a in ar2:
                  mask |= ar1 == a
          return mask
  
      # Otherwise use sorting
      if not assume_unique:
          ar1, rev_idx = np.unique(ar1, return_inverse=True)
          ar2 = np.unique(ar2)
  
      ar = np.concatenate((ar1, ar2))
      # We need this to be a stable sort, so always use 'mergesort'
      # here. The values from the first array should always come before
      # the values from the second array.
      order = ar.argsort(kind="mergesort")
      sar = ar[order]
      if invert:
          bool_ar = sar[1:] != sar[:-1]
      else:
          bool_ar = sar[1:] == sar[:-1]
      flag = np.concatenate((bool_ar, [invert]))
      ret = np.empty(ar.shape, dtype=bool)
      ret[order] = flag
  
      if assume_unique:
          return ret[: len(ar1)]
      else:
          return ret[rev_idx]
  
imports: from __future__ import division, absolute_import, print_function
  import functools
  import numpy
  from numpy.core import overrides
label_desc: Use image node_id 12 for calling a global function with example usage: in1d(ar1, ar2, assume_unique, invert) and returns: mask, ret, ret