code: def reshape(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      shape: Union[ivy.Shape, ivy.NativeShape, Sequence[int]],
      *,
      copy: Optional[bool] = None,
      order: str = "C",
      allowzero: bool = True,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Give a new shape to an array without changing its data.
  
      Parameters
      ----------
      x
          Input array to be reshaped.
      shape
          a new shape compatible with the original shape. One shape dimension
          can be -1. In this case, the value is inferred from the length of the array and
          remaining dimensions.
      copy
          boolean indicating whether or not to copy the input array.
          If True, the function must always copy.
          If False, the function must never copy.
          In case copy is False we avoid copying by returning a view of the input array.
      order
          Read the elements of x using this index order, and place the elements into
          the reshaped array using this index order.
          ``C`` means to read / write the elements using C-like index order,
          with the last axis index changing fastest, back to the first axis index
          changing slowest.
          ``F`` means to read / write the elements using Fortran-like index order, with
          the first index changing fastest, and the last index changing slowest.
          Note that the ``C`` and ``F`` options take no account of the memory layout
          of the underlying array, and only refer to the order of indexing.
          Default order is ``C``
      allowzero
          When ``allowzero=True``, any value in the ``shape`` argument that is equal to
          zero, the zero value is honored. When ``allowzero=False``, any value in the
          ``shape`` argument that is equal to zero the corresponding dimension value is
          copied from the input tensor dynamically.
          Default value is ``True``.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          an output array having the same data type and elements as x.
  
  
      This function conforms to the `Array API Standard
      <https://data-apis.org/array-api/latest/>`_. This docstring is an extension of the
      `docstring <https://data-apis.org/array-api/latest/
      API_specification/generated/array_api.reshape.html>`_
      in the standard.
  
      Both the description and the type hints above assumes an array input for simplicity,
      but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x = ivy.array([[0., 1., 2.],[3., 4., 5.]])
      >>> y = ivy.reshape(x,(3,2))
      >>> print(y)
      ivy.array([[0., 1.],
                 [2., 3.],
                 [4., 5.]])
  
      >>> x = ivy.array([[0., 1., 2.],[3., 4., 5.]])
      >>> y = ivy.reshape(x,(3,2), order='F')
      >>> print(y)
      ivy.array([[0., 4.],
                 [3., 2.],
                 [1., 5.]])
  
      With :class:`ivy.NativeArray` input:
  
      >>> x = ivy.native_array([[0., 1., 2.],[3., 4., 5.]])
      >>> y = ivy.reshape(x,(2,3))
      >>> print(y)
      ivy.array([[0., 1., 2.],
                 [3., 4., 5.]])
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([0, 1, 2, 3, 4, 5]),
      ...                   b=ivy.array([0, 1, 2, 3, 4, 5]))
      >>> y = ivy.reshape(x,(2,3))
      >>> print(y)
      {
          a: ivy.array([[0, 1, 2],
                        [3, 4, 5]]),
          b: ivy.array([[0, 1, 2],
                        [3, 4, 5]])
      }
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([[0., 1., 2.]]), b=ivy.array([[3., 4., 5.]]))
      >>> y = ivy.reshape(x, (-1, 1))
      >>> print(y)
      {
          a: ivy.array([[0.],[1.],[2.]]),
          b: ivy.array([[3.],[4.],[5.]])
      }
      """
      ivy.utils.assertions.check_elem_in_list(order, ["C", "F"])
      return current_backend(x).reshape(
          x,
          shape=shape,
          copy=copy,
          allowzero=allowzero,
          out=out,
          order=order,
      )
  
imports: from typing import Union, Optional, Tuple, List, Iterable, Sequence
  from numbers import Number
  from numpy.core.numeric import normalize_axis_tuple
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, to_native_arrays_and_back, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_view, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 6 for calling a global function with example usage: reshape(shape) and returns: current_backend