code: def log10(x, out=None, where=None, **kwargs):
      """
      Return the base 10 logarithm of the input tensor, element-wise.
  
      Parameters
      ----------
      x : array_like
          Input values.
      out : Tensor, None, or tuple of tensor and None, optional
          A location into which the result is stored. If provided, it must have
          a shape that the inputs broadcast to. If not provided or `None`,
          a freshly-allocated tensor is returned. A tuple (possible only as a
          keyword argument) must have length equal to the number of outputs.
      where : array_like, optional
          Values of True indicate to calculate the ufunc at that position, values
          of False indicate to leave the value in the output alone.
      **kwargs
  
      Returns
      -------
      y : Tensor
          The logarithm to the base 10 of `x`, element-wise. NaNs are
          returned where x is negative.
  
      Notes
      -----
      Logarithm is a multivalued function: for each `x` there is an infinite
      number of `z` such that `10**z = x`. The convention is to return the
      `z` whose imaginary part lies in `[-pi, pi]`.
  
      For real-valued input data types, `log10` always returns real output.
      For each value that cannot be expressed as a real number or infinity,
      it yields ``nan`` and sets the `invalid` floating point error flag.
  
      For complex-valued input, `log10` is a complex analytical function that
      has a branch cut `[-inf, 0]` and is continuous from above on it.
      `log10` handles the floating-point negative zero as an infinitesimal
      negative number, conforming to the C99 standard.
  
      References
      ----------
      .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
             10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
      .. [2] Wikipedia, "Logarithm". http://en.wikipedia.org/wiki/Logarithm
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> mt.log10([1e-15, -3.]).execute()
      array([-15.,  NaN])
      """
      op = TensorLog10(**kwargs)
      return op(x, out=out, where=where)
  
file_path: mars/mars/tensor/arithmetic/log10.py
imports: import numpy
  from ...None import opcodes
  from ..utils import infer_dtype
  from .core import TensorUnaryOp
  from .utils import arithmetic_operand
label_desc: Use image node_id 1 for calling a global function with example usage: log10(x, out, where) and returns: op