code: def array_equivalent(left, right, strict_nan=False):
      """
      True if two arrays, left and right, have equal non-NaN elements, and NaNs
      in corresponding locations.  False otherwise. It is assumed that left and
      right are NumPy arrays of the same dtype. The behavior of this function
      (particularly with respect to NaNs) is not defined if the dtypes are
      different.
  
      Parameters
      ----------
      left, right : ndarrays
      strict_nan : bool, default False
          If True, consider NaN and None to be different.
  
      Returns
      -------
      b : bool
          Returns True if the arrays are equivalent.
  
      Examples
      --------
      >>> array_equivalent(
      ...     np.array([1, 2, np.nan]),
      ...     np.array([1, 2, np.nan]))
      True
      >>> array_equivalent(
      ...     np.array([1, np.nan, 2]),
      ...     np.array([1, 2, np.nan]))
      False
      """
  
      left, right = np.asarray(left), np.asarray(right)
  
      # shape compat
      if left.shape != right.shape:
          return False
  
      # Object arrays can contain None, NaN and NaT.
      # string dtypes must be come to this path for NumPy 1.7.1 compat
      if is_string_dtype(left) or is_string_dtype(right):
          if not strict_nan:
              # isna considers NaN and None to be equivalent.
              return lib.array_equivalent_object(
                  ensure_object(left.ravel()),
                  ensure_object(right.ravel()),
              )
  
          for left_value, right_value in zip(left, right):
              if left_value is NaT and right_value is not NaT:
                  return False
  
              elif isinstance(left_value, float) and np.isnan(
                  left_value
              ):
                  if not isinstance(right_value, float) or not np.isnan(
                      right_value
                  ):
                      return False
              else:
                  if left_value != right_value:
                      return False
          return True
  
      # NaNs can occur in float and complex arrays.
      if is_float_dtype(left) or is_complex_dtype(left):
          # empty
          if not (np.prod(left.shape) and np.prod(right.shape)):
              return True
          return ((left == right) | (isna(left) & isna(right))).all()
  
      # numpy will will not allow this type of datetimelike vs integer comparison
      elif is_datetimelike_v_numeric(left, right):
          return False
  
      # M8/m8
      elif needs_i8_conversion(left) and needs_i8_conversion(right):
          if not is_dtype_equal(left.dtype, right.dtype):
              return False
  
          left = left.view("i8")
          right = right.view("i8")
  
      # if we have structured dtypes, compare first
      if left.dtype.type is np.void or right.dtype.type is np.void:
          if left.dtype != right.dtype:
              return False
  
      return np.array_equal(left, right)
  
file_path: catboost/contrib/python/pandas/py2/pandas/core/dtypes/missing.py
imports: import numpy
  from pandas._libs import lib, missing
  from pandas._libs.tslibs import NaT, iNaT
  from .common import _NS_DTYPE, _TD_DTYPE, ensure_object, is_bool_dtype, is_complex_dtype, is_datetime64_dtype, is_datetime64tz_dtype, is_datetimelike, is_datetimelike_v_numeric, is_dtype_equal, is_extension_array_dtype, is_float_dtype, is_integer_dtype, is_object_dtype, is_period_dtype, is_scalar, is_string_dtype, is_string_like_dtype, is_timedelta64_dtype, needs_i8_conversion, pandas_dtype
  from .generic import ABCDatetimeArray, ABCExtensionArray, ABCGeneric, ABCIndexClass, ABCMultiIndex, ABCSeries, ABCTimedeltaArray
  from .inference import is_list_like
label_desc: Use image node_id 9 for calling a global function with example usage: array_equivalent(left, right, strict_nan) and returns: np, False, True, unknown, lib, True, False, False, False, False, False, False