code: def _docs_manipulation():
      _docs.set_doc(
          chainerx.reshape,
          """reshape(a, newshape)
  Returns a reshaped array.
  
  Args:
      a (~chainerx.ndarray): Array to be reshaped.
      newshape (int or tuple of ints): The new shape of the array to return.
          If it is an integer, then it is treated as a tuple of length one.
          It should be compatible with ``a.size``. One of the elements can be
          -1, which is automatically replaced with the appropriate value to
          make the shape compatible with ``a.size``.
  
  Returns:
      :class:`~chainerx.ndarray`: A reshaped view of ``a`` if possible,
      otherwise a copy.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.reshape`
  """,
      )
  
      _docs.set_doc(
          chainerx.ravel,
          """ravel(a)
  Returns a flattened array.
  
  Args:
      a (~chainerx.ndarray): Array to be flattened.
  
  Returns:
      :class:`~chainerx.ndarray`: A flattened view of ``a`` if possible,
      otherwise a copy.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.ravel`
  """,
      )
  
      _docs.set_doc(
          chainerx.transpose,
          """transpose(a, axes=None)
  Permutes the dimensions of an array.
  
  Args:
      a (~chainerx.ndarray): Array to permute the dimensions.
      axes (tuple of ints): Permutation of the dimensions. This function reverses
          the shape by default.
  
  Returns:
      ~chainerx.ndarray: A view of ``a`` with the dimensions permuted.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.transpose`
  """,
      )
  
      _docs.set_doc(
          chainerx.broadcast_to,
          """broadcast_to(array, shape)
  Broadcasts an array to a given shape.
  
  Args:
      array (~chainerx.ndarray): Array to broadcast.
      shape (tuple of ints): The shape of the desired array.
  
  Returns:
      ~chainerx.ndarray: Broadcasted view.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``array``.
  
  .. seealso:: :func:`numpy.broadcast_to`
  """,
      )
  
      _docs.set_doc(
          chainerx.squeeze,
          """squeeze(a, axis=None)
  Removes size-one axes from the shape of an array.
  
  Args:
      a (~chainerx.ndarray): Array to be reshaped.
      axis (int or tuple of ints): Axes to be removed. This function removes all
          size-one axes by default. If one of the specified axes is not of size
          one, an exception is raised.
  
  Returns:
      ~chainerx.ndarray: An array without (specified) size-one axes.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.squeeze`
  """,
      )
  
      _docs.set_doc(
          chainerx.concatenate,
          """concatenate(arrays, axis=0)
  Joins arrays along an axis.
  
  Args:
      arrays (sequence of :class:`~chainerx.ndarray`\\ s): Arrays to be joined.
          All of these should have the same dimensionalities except the specified
          axis.
      axis (int): The axis to join arrays along.
  
  
  Returns:
      ~chainerx.ndarray: Joined array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays in ``arrays``.
  
  .. seealso:: :func:`numpy.concatenate`
  """,
      )
  
      _docs.set_doc(
          chainerx.stack,
          """stack(arrays, axis=0)
  Stacks arrays along a new axis.
  
  Args:
      arrays (sequence of :class:`~chainerx.ndarray`\\ s): Arrays to be stacked.
      axis (int): Axis along which the arrays are stacked.
  
  Returns:
      ~chainerx.ndarray: Stacked array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays in ``arrays``.
  
  .. seealso:: :func:`numpy.stack`
  """,
      )
  
      _docs.set_doc(
          chainerx.hstack,
          """hstack(arrays)
  Stack arrays in sequence horizontally (column wise).
  
  Args:
      arrays (sequence of :class:`~chainerx.ndarray`\\ s): Arrays to be stacked.
  
  Returns:
      ~chainerx.ndarray: Stacked array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays in ``arrays``.
  
  .. seealso:: :func:`numpy.hstack`
  """,
      )
  
      _docs.set_doc(
          chainerx.vstack,
          """vstack(arrays)
  Stack arrays in sequence vertically (row wise).
  
  Args:
      arrays (sequence of :class:`~chainerx.ndarray`\\ s): Arrays to be stacked.
  
  Returns:
      ~chainerx.ndarray: Stacked array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays in ``arrays``.
  
  .. seealso:: :func:`numpy.vstack`
  """,
      )
  
      _docs.set_doc(
          chainerx.dstack,
          """dstack(arrays)
  Stack arrays in sequence depth wise (along third axis).
  
  Args:
      arrays (sequence of :class:`~chainerx.ndarray`\\ s): Arrays to be stacked.
  
  Returns:
      ~chainerx.ndarray: Stacked array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays in ``arrays``.
  
  .. seealso:: :func:`numpy.dstack`
  """,
      )
  
      _docs.set_doc(
          chainerx.atleast_2d,
          """atleast_2d(a)
  View inputs as arrays with at least two dimensions.
  
  Args:
      a (~chainerx.ndarray): Array.
  
  Returns:
      ~chainerx.ndarray: An array with a.ndim >= 2.
      Copies are avoided where possible, and views with
      two or more dimensions are returned.
  
  Note:
      * Arrays that already have two or more dimensions are preserved.
      * During backpropagation, this function propagates the gradient of the
        output array to the input arrays in ``a``.
  
  .. seealso:: :func:`numpy.atleast_2d`
  """,
      )
  
      _docs.set_doc(
          chainerx.atleast_3d,
          """atleast_3d(a)
  View inputs as arrays with at least three dimensions.
  
  Args:
      a (~chainerx.ndarray): Array.
  
  Returns:
      ~chainerx.ndarray: An array with a.ndim >= 3.
      Copies are avoided where possible, and views with
      three or more dimensions are returned.
  
  Note:
      * Arrays that already have three or more dimensions are preserved.
      * During backpropagation, this function propagates the gradient of the
        output array to the input arrays in ``a``.
  
  .. seealso:: :func:`numpy.atleast_3d`
  """,
      )
  
      _docs.set_doc(
          chainerx.split,
          """split(ary, indices_or_sections, axis=0)
  Splits an array into multiple sub arrays along a given axis.
  
  Args:
      ary (~chainerx.ndarray): Array to split.
      indices_or_sections (int or sequence of ints): A value indicating how to
          divide the axis. If it is an integer, then is treated as the number of
          sections, and the axis is evenly divided. Otherwise, the integers
          indicate indices to split at. Note that a sequence on the device
          memory is not allowed.
      axis (int): Axis along which the array is split.
  
  Returns:
      list of :class:`~chainerx.ndarray`\\ s: A list of sub arrays. Each array \
  is a partial view of the input array.
  
  Note:
      During backpropagation, this function propagates the gradients of the
      output arrays to the input array ``ary``.
  
  .. seealso:: :func:`numpy.split`
  """,
      )
  
      _docs.set_doc(
          chainerx.dsplit,
          """dsplit(ary, indices_or_sections)
  Split array into multiple sub-arrays along the 3rd axis (depth).
  
  Args:
      ary (~chainerx.ndarray): Array to split.
      indices_or_sections (int or sequence of ints): A value indicating how to
          divide the axis. If it is an integer, then is treated as the number of
          sections, and the axis is evenly divided. Otherwise, the integers
          indicate indices to split at. Note that a sequence on the device
          memory is not allowed.
  
  Returns:
      list of :class:`~chainerx.ndarray`\\ s: A list of sub arrays. Each array \
  is a partial view of the input array.
  
  Note:
      During backpropagation, this function propagates the gradients of the
      output arrays to the input array ``ary``.
  
  .. seealso:: :func:`numpy.dsplit`
  """,
      )
  
      _docs.set_doc(
          chainerx.vsplit,
          """vsplit(ary, indices_or_sections)
  Splits an array into multiple sub-arrays vertically (row-wise).
  
  Args:
      ary (~chainerx.ndarray): Array to split.
      indices_or_sections (int or sequence of ints): A value indicating how to
          divide the axis. If it is an integer, then is treated as the number of
          sections, and the axis is evenly divided. Otherwise, the integers
          indicate indices to split at. Note that a sequence on the device
          memory is not allowed.
  
  Returns:
      list of :class:`~chainerx.ndarray`\\ s: A list of sub arrays. Each array \
  is a partial view of the input array.
  
  Note:
      During backpropagation, this function propagates the gradients of the
      output arrays to the input array ``ary``.
  
  .. seealso:: :func:`numpy.vsplit`
  """,
      )
  
      _docs.set_doc(
          chainerx.hsplit,
          """hsplit(ary, indices_or_sections)
  Split an array into multiple sub-arrays horizontally (column-wise).
  
  Args:
      ary (~chainerx.ndarray): Array to split.
      indices_or_sections (int or sequence of ints): A value indicating how to
          divide the axis. If it is an integer, then is treated as the number of
          sections, and the axis is evenly divided. Otherwise, the integers
          indicate indices to split at. Note that a sequence on the device
          memory is not allowed.
  
  Returns:
      list of :class:`~chainerx.ndarray`\\ s: A list of sub arrays. Each array \
  is a partial view of the input array.
  
  Note:
      During backpropagation, this function propagates the gradients of the
      output arrays to the input array ``ary``.
  
  .. seealso:: :func:`numpy.hsplit`
  """,
      )
  
      _docs.set_doc(
          chainerx.swapaxes,
          """swapaxes(a, axis1, axis2)
  Interchange two axes of an array.
  
  Args:
      a (~chainerx.ndarray): Array to swapaxes.
      axis1 (int): First Axis
      axis2 (int): Second Axis
  
  Returns:
      ~chainerx.ndarray: Swaped array.
  
  Note:
      * Output array is a view of the input array.
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``a``.
  
  
  .. seealso:: :func:`numpy.swapaxes`
  """,
      )
  
      _docs.set_doc(
          chainerx.repeat,
          """repeat(a, repeats, axis=None)
  Constructs an array by repeating a given array.
  
  Args:
      a (~chainerx.ndarray): Array to repeat.
      repeats (int or tuple of ints): The number of times which each
          element of a is repeated.
      axis (int): The axis along which to repeat values.
  
  Returns:
      ~chainerx.ndarray: The repeated output array.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.repeat`
  """,
      )
  
      _docs.set_doc(
          chainerx.expand_dims,
          """expand_dims(a, axis)
  Expand the shape of an array.
  
  Args:
      a (~chainerx.ndarray): Input Array.
      axis (int): Position in the expanded axes where the new axis is placed.
  
  Returns:
      ~chainerx.ndarray: Output array.
  
  Note:
      * Output array may or may not be a view of the input array.
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``a``.
  
  
  .. seealso:: :func:`numpy.expand_dims`
  """,
      )
  
      _docs.set_doc(
          chainerx.flip,
          """flip(m, axis)
  Reverse the order of elements in an array along the given axis.
  
  Args:
      m (~chainerx.ndarray): Input Array.
      axis (int or tuple of ints): Axis or axes along which to flip over.
      The default, axis=None, will flip over all of the axes of the input array.
      If axis is negative it counts from the last to the first axis.
      If axis is a tuple of ints, flipping is performed on all of the
      axes specified in the tuple.
  
  Returns:
      ~chainerx.ndarray: A view of m with the entries of axis reversed.
      Since a view is returned, this operation is done in constant time.
  
  Note:
      * Output array is a view of the input array.
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``m``.
  
  
  .. seealso:: :func:`numpy.flip`
  """,
      )
  
      _docs.set_doc(
          chainerx.fliplr,
          """fliplr(m)
  Flip array in the left/right direction.
  
  Args:
      m (~chainerx.ndarray): Input Array.
  
  Returns:
      ~chainerx.ndarray: A view of m with the columns reversed.
      Since a view is returned, this operation is done in constant time.
  
  Note:
      * Output array is a view of the input array.
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``m``.
  
  
  .. seealso:: :func:`numpy.fliplr`
  """,
      )
  
      _docs.set_doc(
          chainerx.flipud,
          """flipud(m)
  Flip array in the up/down direction.
  
  Args:
      m (~chainerx.ndarray): Input Array.
  
  Returns:
      ~chainerx.ndarray: A view of m with the rows reversed.
      Since a view is returned, this operation is done in constant time.
  
  Note:
      * Output array is a view of the input array.
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``m``.
  
  
  .. seealso:: :func:`numpy.flipud`
  """,
      )
  
      _docs.set_doc(
          chainerx.moveaxis,
          """moveaxis(a, source, destination)
  Move axes of an array to new positions.
  
  Other axes remain in their original order.
  
  Args:
      a (~chainerx.ndarray): Input Array.
      source (int or tuple of ints): Original positions of the axes to move.
      These must be unique.
      destintation (int or tuple of ints): Destination positions for each of
      the original axes. These must also be unique.
  
  Returns:
      ~chainerx.ndarray: Array with moved axes. This array is a view of the
      input array.
  
  Note:
      * During backpropagation, this function propagates the gradients of the
        output arrays to the input array ``a``.
  
  
  .. seealso:: :func:`numpy.moveaxis`
  """,
      )
  
file_path: chainer/chainerx/_docs/routines.py
imports: import chainerx
  from chainerx import _docs
label_desc: Use image node_id 8 for calling a global function with example usage: _docs_manipulation() without return types