# xmanipulation

Defined in `xtensor/misc/xmanipulation.hpp`

group Xt_xmanipulation

  Functions

  template<class E>
  inline auto transpose(E &&e) noexcept

    Returns a transpose view by reversing the dimensions of xexpression e.

    Parameters:

      e – the input expression

  template<class E, class S, class Tag = check_policy::none>
  inline auto transpose(E &&e, S &&permutation, Tag check_policy)

    Returns a transpose view by permuting the xexpression e with `permutation`.

    Parameters:

      - e – the input expression

      - permutation – the sequence containing permutation

      - check_policy – the check level (check_policy::full() or check_policy::none())

    Template Parameters:

      Tag – selects the level of error checking on permutation vector defaults to check_policy::none.

  template<class E>
  inline auto swapaxes(E &&e, std::ptrdiff_t axis1, std::ptrdiff_t axis2)

    Return a new expression with two axes interchanged.

    The two axis parameter `axis` and `axis2` are interchangable.

    Parameters:

      - e – The input expression

      - axis1 – First axis to swap

      - axis2 – Second axis to swap

  template<class E>
  inline auto moveaxis(E &&e, std::ptrdiff_t src, std::ptrdiff_t dest)

    Return a new expression with an axis move to a new position.

    Parameters:

      - e – The input expression

      - src – Original position of the axis to move

      - dest – Destination position for the original axis.

  template<layout_type L = ::xt::layout_type::row_major, class E>
  inline auto ravel(E &&e)

    Return a flatten view of the given expression.

    No copy is made.

    Parameters:

      e – the input expression

    Template Parameters:

      - L – the layout used to read the elements of e. If no parameter is specified, XTENSOR_DEFAULT_TRAVERSAL is used.

      - E – the type of the expression

  template<layout_type L = ::xt::layout_type::row_major, class E>
  inline auto flatten(E &&e)

    Return a flatten view of the given expression.

    No copy is made. This method is equivalent to ravel and is provided for API sameness with NumPy.

    See also

    ravel

    Parameters:

      e – the input expression

    Template Parameters:

      - L – the layout used to read the elements of e. If no parameter is specified, XTENSOR_DEFAULT_TRAVERSAL is used.

      - E – the type of the expression

  template<class E>
  inline auto trim_zeros(E &&e, const std::string &direction)

    Trim zeros at beginning, end or both of 1D sequence.

    Parameters:

      - e – input xexpression

      - direction – string of either ‘f’ for trim from beginning, ‘b’ for trim from end or ‘fb’ (default) for both.

    Returns:

      returns a view without zeros at the beginning and end

  template<class E>
  inline auto squeeze(E &&e)

    Returns a squeeze view of the given expression.

    No copy is made. Squeezing an expression removes dimensions of extent 1.

    Parameters:

      e – the input expression

    Template Parameters:

      E – the type of the expression

  template<class E, xtl::non_integral_concept S, class Tag = check_policy::none>
  inline auto squeeze(E &&e, S &&axis, Tag check_policy)

    Remove single-dimensional entries from the shape of an xexpression.

    Parameters:

      - e – input xexpression

      - axis – integer or container of integers, select a subset of single-dimensional entries of the shape.

      - check_policy – select check_policy. With check_policy::full(), selecting an axis which is greater than one will throw a runtime_error.

  template<class E>
  inline auto expand_dims(E &&e, std::size_t axis)

    Expand the shape of an xexpression.

    Insert a new axis that will appear at the axis position in the expanded array shape. This will return a `strided_view` with a `xt::newaxis()` at the indicated axis.

    Parameters:

      - e – input xexpression

      - axis – axis to expand

    Returns:

      returns a `strided_view` with expanded dimension

  template<std::size_t N, class E>
  inline auto atleast_Nd(E &&e)

    Expand dimensions of xexpression to at least `N`.

    This adds `newaxis()` slices to a `strided_view` until the dimension of the view reaches at least `N`. Note: dimensions are added equally at the beginning and the end. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1).

    Parameters:

      e – input xexpression

    Template Parameters:

      N – the number of requested dimensions

    Returns:

      `strided_view` with expanded dimensions

  template<class E>
  inline auto atleast_1d(E &&e)

    Expand to at least 1D.

    See also

    atleast_Nd

  template<class E>
  inline auto atleast_2d(E &&e)

    Expand to at least 2D.

    See also

    atleast_Nd

  template<class E>
  inline auto atleast_3d(E &&e)

    Expand to at least 3D.

    See also

    atleast_Nd

  template<class E>
  inline auto split(E &e, std::size_t n, std::size_t axis)

    Split xexpression along axis into subexpressions.

    This splits an xexpression along the axis in `n` equal parts and returns a vector of `strided_view`. Calling split with axis > dimension of e or a `n` that does not result in an equal division of the xexpression will throw a runtime_error.

    Parameters:

      - e – input xexpression

      - n – number of elements to return

      - axis – axis along which to split the expression

  template<class E>
  inline auto hsplit(E &e, std::size_t n)

    Split an xexpression into subexpressions horizontally (column-wise).

    This method is equivalent to `split(e, n, 1)`.

    Parameters:

      - e – input xexpression

      - n – number of elements to return

  template<class E>
  inline auto vsplit(E &e, std::size_t n)

    Split an xexpression into subexpressions vertically (row-wise).

    This method is equivalent to `split(e, n, 0)`.

    Parameters:

      - e – input xexpression

      - n – number of elements to return

  template<class E>
  inline auto flip(E &&e)

    Reverse the order of elements in an xexpression along every axis.

    Parameters:

      e – the input xexpression

    Returns:

      returns a view with the result of the flip.

  template<class E>
  inline auto flip(E &&e, std::size_t axis)

    Reverse the order of elements in an xexpression along the given axis.

    Note: A NumPy/Matlab style `flipud(arr)` is equivalent to `xt::flip(arr, 0)`, `fliplr(arr)` to `xt::flip(arr, 1)`.

    Parameters:

      - e – the input xexpression

      - axis – the axis along which elements should be reversed

    Returns:

      returns a view with the result of the flip

  template<std::ptrdiff_t N = 1, class E>
  inline auto rot90(E &&e, const std::array<std::ptrdiff_t, 2> &axes)

    Rotate an array by 90 degrees in the plane specified by axes.

    Rotation direction is from the first towards the second axis.

    Parameters:

      - e – the input xexpression

      - axes – the array is rotated in the plane defined by the axes. Axes must be different.

    Template Parameters:

      N – number of times the array is rotated by 90 degrees. Default is 1.

    Returns:

      returns a view with the result of the rotation

  template<class E>
  inline auto roll(E &&e, std::ptrdiff_t shift)

    Roll an expression.

    The expression is flatten before shifting, after which the original shape is restore. Elements that roll beyond the last position are re-introduced at the first. This function does not change the input expression.

    Parameters:

      - e – the input xexpression

      - shift – the number of places by which elements are shifted

    Returns:

      a roll of the input expression

  template<class E>
  inline auto roll(E &&e, std::ptrdiff_t shift, std::ptrdiff_t axis)

    Roll an expression along a given axis.

    Elements that roll beyond the last position are re-introduced at the first. This function does not change the input expression.

    Parameters:

      - e – the input xexpression

      - shift – the number of places by which elements are shifted

      - axis – the axis along which elements are shifted.

    Returns:

      a roll of the input expression

  template<class E>
  inline auto repeat(E &&e, std::size_t repeats, std::size_t axis)

    Repeat elements of an expression along a given axis.

    Parameters:

      - e – the input xexpression

      - repeats – The number of repetition of each elements. `repeats` is broadcasted to fit the shape of the given `axis`.

      - axis – the axis along which to repeat the value

    Returns:

      an expression which as the same shape as e, except along the given axis

  template<class E>
  inline auto repeat(E &&e, const std::vector<std::size_t> &repeats, std::size_t axis)

    Repeat elements of an expression along a given axis.

    Parameters:

      - e – the input xexpression

      - repeats – The number of repetition of each elements. The size of `repeats` must match the shape of the given `axis`.

      - axis – the axis along which to repeat the value

    Returns:

      an expression which as the same shape as e, except along the given axis

  template<class E>
  inline auto repeat(E &&e, std::vector<std::size_t> &&repeats, std::size_t axis)

    Repeat elements of an expression along a given axis.

    Parameters:

      - e – the input xexpression

      - repeats – The number of repetition of each elements. The size of `repeats` must match the shape of the given `axis`.

      - axis – the axis along which to repeat the value

    Returns:

      an expression which as the same shape as e, except along the given axis