code: def around(a, decimals=0, out=None):
      """
      Evenly round to the given number of decimals.
  
      Parameters
      ----------
      a : array_like
          Input data.
      decimals : int, optional
          Number of decimal places to round to (default: 0).  If
          decimals is negative, it specifies the number of positions to
          the left of the decimal point.
      out : Tensor, optional
          Alternative output tensor in which to place the result. It must have
          the same shape as the expected output, but the type of the output
          values will be cast if necessary.
  
      Returns
      -------
      rounded_array : Tensor
          An tensor of the same type as `a`, containing the rounded values.
          Unless `out` was specified, a new tensor is created.  A reference to
          the result is returned.
  
          The real and imaginary parts of complex numbers are rounded
          separately.  The result of rounding a float is a float.
  
      See Also
      --------
      Tensor.round : equivalent method
  
      ceil, fix, floor, rint, trunc
  
  
      Notes
      -----
      For values exactly halfway between rounded decimal values, NumPy
      rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
      -0.5 and 0.5 round to 0.0, etc. Results may also be surprising due
      to the inexact representation of decimal fractions in the IEEE
      floating point standard [1]_ and errors introduced when scaling
      by powers of ten.
  
      References
      ----------
      .. [1] "Lecture Notes on the Status of  IEEE 754", William Kahan,
             http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
      .. [2] "How Futile are Mindless Assessments of
             Roundoff in Floating-Point Computation?", William Kahan,
             http://www.cs.berkeley.edu/~wkahan/Mindless.pdf
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> mt.around([0.37, 1.64]).execute()
      array([ 0.,  2.])
      >>> mt.around([0.37, 1.64], decimals=1).execute()
      array([ 0.4,  1.6])
      >>> mt.around([.5, 1.5, 2.5, 3.5, 4.5]).execute() # rounds to nearest even value
      array([ 0.,  2.,  2.,  4.,  4.])
      >>> mt.around([1,2,3,11], decimals=1).execute() # tensor of ints is returned
      array([ 1,  2,  3, 11])
      >>> mt.around([1,2,3,11], decimals=-1).execute()
      array([ 0,  0,  0, 10])
  
      """
      dtype = astensor(a).dtype
      op = TensorAround(decimals=decimals, dtype=dtype)
      return op(a, out=out)
  
file_path: mars/mars/tensor/arithmetic/around.py
imports: import numpy
  from ...None import opcodes
  from ...serialization.serializables import Int32Field
  from ..array_utils import device, as_same_device
  from ..datasource import tensor
  from .core import TensorUnaryOp
  from .utils import arithmetic_operand
label_desc: Use image node_id 1 for calling a global function with example usage: around(a, decimals, out) and returns: op