code: def tile(x, reps):
      """Construct an array by tiling a given array.
  
  
      Args:
          x (:class:`~chainer.Variable` or :ref:`ndarray`):
              Input variable. Let the length of ``reps`` be ``d``. If
              ``x.ndim < d``, ``x`` is treated as ``d``-dimensional array by
              prepending new axes. For example, when the shape of ``x`` is
              ``(2,)`` and tiled with 2-dim repetitions, ``x`` is treated as the
              shape ``(1, 2)``. If ``x.ndim > d``, ``reps`` is treated as
              ``x.ndim``-dimensional by pre-pending 1's. For example, when the
              shape of ``x`` is ``(2, 3, 2, 3)``, the 2-dim ``reps`` of
              ``(2, 2)`` is treated as ``(1, 1, 2, 2)``.
          reps (:class:`int` or :class:`tuple` of :class:`int` s):
              The number of times which ``x`` is replicated along each axis.
  
      Returns:
          ~chainer.Variable: The tiled output Variable.
          Let the length of ``reps`` be ``d``, the output has the dimension of
          ``max(d, x.ndim)``.
  
      .. admonition:: Example
  
          >>> x = np.array([0, 1, 2])
          >>> x.shape
          (3,)
          >>> y = F.tile(x, 2)
          >>> y.shape
          (6,)
          >>> y.array
          array([0, 1, 2, 0, 1, 2])
          >>> y = F.tile(x, (2, 2))
          >>> y.shape
          (2, 6)
          >>> y.array
          array([[0, 1, 2, 0, 1, 2],
                 [0, 1, 2, 0, 1, 2]])
          >>> y = F.tile(x, (2, 1, 2))
          >>> y.shape
          (2, 1, 6)
          >>> y.array
          array([[[0, 1, 2, 0, 1, 2]],
          <BLANKLINE>
                 [[0, 1, 2, 0, 1, 2]]])
  
          >>> x = np.array([[1, 2], [3, 4]])
          >>> x.shape
          (2, 2)
          >>> y = F.tile(x, 2)
          >>> y.shape
          (2, 4)
          >>> y.array
          array([[1, 2, 1, 2],
                 [3, 4, 3, 4]])
          >>> y = F.tile(x, (2, 2))
          >>> y.shape
          (4, 4)
          >>> y.array
          array([[1, 2, 1, 2],
                 [3, 4, 3, 4],
                 [1, 2, 1, 2],
                 [3, 4, 3, 4]])
          >>> y = F.tile(x, (2, 1, 2))
          >>> y.shape
          (2, 2, 4)
          >>> y.array
          array([[[1, 2, 1, 2],
                  [3, 4, 3, 4]],
          <BLANKLINE>
                 [[1, 2, 1, 2],
                  [3, 4, 3, 4]]])
  
      """
      return Tile(reps).apply((x,))[0]
  
file_path: chainer/chainer/functions/array/tile.py
imports: import six
  import chainer
  from chainer import backend
  from chainer import function_node
  from chainer.utils import type_check
label_desc: Use image node_id 1 for calling a global function with example usage: tile(x, reps) and returns: Tile