code: def allclose(a, b, rtol=4*np.finfo(float).eps, atol=0.0, equal_nan=False, verbose=False):
      
      close = isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)
      result = np.all(close)
      if verbose and not result:
          print('Non-close values:')
          for i in np.argwhere(close == False):
              i = tuple(i)
              print('\n    x[{0}]={1}\n    y[{0}]={2}'.format(i, a[i], b[i]))
      return result
docs: Returns True if two arrays are element-wise equal within a tolerance.
  
      This function is essentially a wrapper for the `quaternion.isclose`
      function, but returns a single boolean value of True if all elements
      of the output from `quaternion.isclose` are True, and False otherwise.
      This function also adds the option.
  
      Note that this function has stricter tolerances than the
      `numpy.allclose` function, as well as the additional `verbose` option.
  
      Parameters
      ----------
      a, b : array_like
          Input arrays to compare.
      rtol : float
          The relative tolerance parameter (see Notes).
      atol : float
          The absolute tolerance parameter (see Notes).
      equal_nan : bool
          Whether to compare NaN's as equal.  If True, NaN's in `a` will be
          considered equal to NaN's in `b` in the output array.
      verbose : bool
          If the return value is False,
  
      Returns
      -------
      allclose : bool
          Returns True if the two arrays are equal within the given
          tolerance; False otherwise.
      See Also
      --------
      isclose, numpy.all, numpy.any, numpy.allclose
  
      Returns
      -------
      allclose : bool
          Returns True if the two arrays are equal within the given
          tolerance; False otherwise.
  
  
      Notes
      -----
      If the following equation is element-wise True, then allclose returns
      True.
  
        absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
  
      The above equation is not symmetric in `a` and `b`, so that
      `allclose(a, b)` might be different from `allclose(b, a)` in
      some rare cases.