docstr: ivy.Array instance method variant of ivy.take.
  
  This method simply wraps the function, and so the docstring for
  ivy.take also applies to this method with minimal changes.
  
  Parameters
  ----------
  self
      input array
  indices
      array indices. Must have an integer data type.
  axis
      axis over which to select values. If `axis` is negative,
      the function must determine the axis along which to select values
      by counting from the last dimension.
      By default, the flattened input array is used.
  mode
      specifies how out-of-bounds `indices` will behave.
      -   ‘raise’ – raise an error
      -   ‘wrap’ – wrap around
      -   ‘clip’ – clip to the range (all indices that are too large are
      replaced by the index that addresses the last element along that axis.
      Note that this disables indexing with negative numbers.)
      -   'fill' (default) = returns invalid values (e.g. NaN)
      for out-of bounds indices (see also fill_value below)
  fill_value
      fill value to return for out-of-bounds slices
      (Defaults to NaN for inexact types,
      the largest negative value for signed types,
      the largest positive value for unsigned types, and True for booleans.)
  out
      optional output array, for writing the result to. It must
      have a shape that the inputs broadcast to.
  
  Returns
  -------
      ret
          an array having the same data type as `x`.
          The output array must have the same rank
          (i.e., number of dimensions) as `x` and
          must have the same shape as `x`, except
          for the axis specified by `axis`
          whose size must equal the number of elements in `indices`.
  
  Examples
  --------
  With `ivy.Array` input:
  
  >>> x = ivy.array([4,5,6])
  >>> indices = ivy.array([2,1,0])
  >>> y = x.take(indices)
  >>> print(y)
  ivy.array([6, 5, 4])
  
  >>> x = ivy.array([4.7,5.2,6.5])
  >>> indices = ivy.array([[0,1]])
  >>> y = ivy.zeros_like(indices, dtype=x.dtype)
  >>> x.take(indices, out=y)
  >>> print(y)
  ivy.array([[4.7, 5.2]])
  
  >>> x = ivy.array([False, False, True])
  >>> indices = ivy.array([[4,3,2]])
  >>> y = ivy.zeros_like(indices, dtype=x.dtype)
  >>> x.take(indices, out=y, mode="wrap")
  >>> print(y)
  ivy.array([[False, False, True]])
code: def take(
      self: ivy.Array,
      indices: Union[int, ivy.Array, ivy.NativeArray],
      /,
      *,
      axis: Optional[int] = None,
      mode: str = "fill",
      fill_value: Optional[Number] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """ivy.Array instance method variant of ivy.take.
  
      This method simply wraps the function, and so the docstring for
      ivy.take also applies to this method with minimal changes.
  
      Parameters
      ----------
      self
          input array
      indices
          array indices. Must have an integer data type.
      axis
          axis over which to select values. If `axis` is negative,
          the function must determine the axis along which to select values
          by counting from the last dimension.
          By default, the flattened input array is used.
      mode
          specifies how out-of-bounds `indices` will behave.
          -   ‘raise’ – raise an error
          -   ‘wrap’ – wrap around
          -   ‘clip’ – clip to the range (all indices that are too large are
          replaced by the index that addresses the last element along that axis.
          Note that this disables indexing with negative numbers.)
          -   'fill' (default) = returns invalid values (e.g. NaN)
          for out-of bounds indices (see also fill_value below)
      fill_value
          fill value to return for out-of-bounds slices
          (Defaults to NaN for inexact types,
          the largest negative value for signed types,
          the largest positive value for unsigned types, and True for booleans.)
      out
          optional output array, for writing the result to. It must
          have a shape that the inputs broadcast to.
  
      Returns
      -------
          ret
              an array having the same data type as `x`.
              The output array must have the same rank
              (i.e., number of dimensions) as `x` and
              must have the same shape as `x`, except
              for the axis specified by `axis`
              whose size must equal the number of elements in `indices`.
  
      Examples
      --------
      With `ivy.Array` input:
  
      >>> x = ivy.array([4,5,6])
      >>> indices = ivy.array([2,1,0])
      >>> y = x.take(indices)
      >>> print(y)
      ivy.array([6, 5, 4])
  
      >>> x = ivy.array([4.7,5.2,6.5])
      >>> indices = ivy.array([[0,1]])
      >>> y = ivy.zeros_like(indices, dtype=x.dtype)
      >>> x.take(indices, out=y)
      >>> print(y)
      ivy.array([[4.7, 5.2]])
  
      >>> x = ivy.array([False, False, True])
      >>> indices = ivy.array([[4,3,2]])
      >>> y = ivy.zeros_like(indices, dtype=x.dtype)
      >>> x.take(indices, out=y, mode="wrap")
      >>> print(y)
      ivy.array([[False, False, True]])
      """
      return ivy.take(
          self,
          indices,
          axis=axis,
          mode=mode,
          fill_value=fill_value,
          out=out,
      )
  
imports: import abc
  from typing import Optional, Union, Sequence, Tuple, List, Iterable, Callable, Literal, Any
  from numbers import Number
  import ivy
  from ivy import handle_view
label_desc: Use image node_id 26 for calling the _ArrayWithManipulationExperimental obj's underlying member method code with example usage: obj.take() and returns: ivy