code: def _compare_or_regex_search(a, b, regex=False):
      
      if not regex:
          op = lambda x: operator.eq(x, b)
      else:
          op = np.vectorize(lambda x: bool(re.search(b, x)) if isinstance(x, str)
                            else False)
  
      is_a_array = isinstance(a, np.ndarray)
      is_b_array = isinstance(b, np.ndarray)
  
      # numpy deprecation warning to have i8 vs integer comparisons
      if is_datetimelike_v_numeric(a, b):
          result = False
  
      # numpy deprecation warning if comparing numeric vs string-like
      elif is_numeric_v_string_like(a, b):
          result = False
      else:
          result = op(a)
  
      if is_scalar(result) and (is_a_array or is_b_array):
          type_names = [type(a).__name__, type(b).__name__]
  
          if is_a_array:
              type_names[0] = 'ndarray(dtype={dtype})'.format(dtype=a.dtype)
  
          if is_b_array:
              type_names[1] = 'ndarray(dtype={dtype})'.format(dtype=b.dtype)
  
          raise TypeError(
              "Cannot compare types {a!r} and {b!r}".format(a=type_names[0],
                                                            b=type_names[1]))
      return result
docs: Compare two array_like inputs of the same shape or two scalar values
  
      Calls operator.eq or re.search, depending on regex argument. If regex is
      True, perform an element-wise regex matching.
  
      Parameters
      ----------
      a : array_like or scalar
      b : array_like or scalar
      regex : bool, default False
  
      Returns
      -------
      mask : array_like of bool