# xmanipulation

Defined in `xtensor/xmanipulation.hpp`

template<std::size_t N, class E>
inline auto xt::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 xt::atleast_1d(E &&e)

  Expand to at least 1D.

  See

    atleast_Nd

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

  Expand to at least 2D.

  See

    atleast_Nd

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

  Expand to at least 3D.

  See

    atleast_Nd

template<class E>
inline auto xt::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<layout_type L = ::xt::layout_type::row_major, class E>
inline auto xt::flatten(E &&e)

  Returns 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

    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<layout_type L, class T>
inline auto xt::flatnonzero(const T &arr)

  return indices that are non-zero in the flattened version of arr, equivalent to nonzero(ravel<layout_type>(arr))[0];

  Parameters

    arr – input array

  Returns

    indices that are non-zero in the flattened version of arr

Warning

doxygenfunction: Unable to resolve function “xt::flip” with arguments None in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

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

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

  Returns 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<class E>
inline auto xt::repeat(E &&e, std::size_t repeats, std::size_t axis)

  Repeats 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 xt::repeat(E &&e, const std::vector<std::size_t> &repeats, std::size_t axis)

  Repeats 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 xt::repeat(E &&e, std::vector<std::size_t> &&repeats, std::size_t axis)

  Repeats 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 xt::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 xt::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<std::ptrdiff_t N = 1, class E>
inline auto xt::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 xt::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 xt::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 xt::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 xt::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, class S, class Tag = check_policy::none, std::enable_if_t<!xtl::is_integral<S>::value, int> = 0>
inline auto xt::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 xt::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 xt::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 xt::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