code: def values_eq_approx(
      a,
      b,
      allow_remove_inf=False,
      allow_remove_nan=False,
      rtol=None,
      atol=None,
  ):
      """
      Parameters
      ----------
      allow_remove_inf
          If True, when there is an inf in a, we allow any value in b in
          that position. Event -inf
      allow_remove_nan
          If True, when there is a nan in a, we allow any value in b in
          that position. Event +-inf
      rtol
          Relative tolerance, passed to _allclose.
      atol
          Absolute tolerance, passed to _allclose.
  
      """
      if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
          if a.shape != b.shape:
              return False
          if a.dtype != b.dtype:
              return False
          if str(a.dtype) not in theano.tensor.continuous_dtypes:
              return np.all(a == b)
          else:
              cmp = theano.tensor.basic._allclose(
                  a, b, rtol=rtol, atol=atol
              )
              if cmp:
                  # Numpy claims they are close, this is good enough for us.
                  return True
              # Numpy is unhappy, but it does not necessarily mean that a and
              # b are different. Indeed, Numpy does not like missing values
              # and will return False whenever some are found in a or b.
              # The proper way would be to use the MaskArray stuff available
              # in Numpy. However, it looks like it has been added to Numpy's
              # core recently, so it may not be available to everyone. Thus,
              # for now we use a home-made recipe, that should probably be
              # revisited in the future.
              a_missing = np.isnan(a)
              a_inf = np.isinf(a)
  
              if not (
                  a_missing.any() or (allow_remove_inf and a_inf.any())
              ):
                  # There are no missing values in a, thus this is not the
                  # reason why numpy.allclose(a, b) returned False.
                  _logger.info(
                      "numpy allclose failed for abs_err %f and rel_err %f",
                      np.max(abs(a - b)),
                      np.max(abs(a - b) / (abs(a) + abs(b))),
                  )
                  return False
              # The following line is what numpy.allclose bases its decision
              # upon, according to its documentation.
              rtol = 1.0000000000000001e-05
              atol = 1e-8
              cmp_elemwise = np.absolute(a - b) <= (
                  atol + rtol * np.absolute(b)
              )
              # Find places where both a and b have missing values.
              both_missing = a_missing * np.isnan(b)
  
              # Find places where both a and b have inf of the same sign.
              both_inf = a_inf * np.isinf(b)
  
              # cmp_elemwise is weird when we have inf and -inf.
              # set it to False
              cmp_elemwise = np.where(
                  both_inf & cmp_elemwise, a == b, cmp_elemwise
              )
  
              # check the sign of the inf
              both_inf = np.where(both_inf, (a == b), both_inf)
  
              if allow_remove_inf:
                  both_inf += a_inf
              if allow_remove_nan:
                  both_missing += a_missing
  
              # Combine all information.
              return (cmp_elemwise + both_missing + both_inf).all()
  
      return False
  
imports: from __future__ import absolute_import, print_function, division
  import logging
  import warnings
  import numpy
  import theano
  from theano import config
  from theano.gof import hashtype, Type, Variable
  from theano import scalar
label_desc: Use image node_id 1 for calling a global function with example usage: values_eq_approx(a, b, allow_remove_inf, allow_remove_nan, rtol, atol) and returns: False, False, False, np, unknown, True, False