xmanipulation

Defined in xtensor/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, class S, class Tag = check_policy::none, std::enable_if_t<!xtl::is_integral<S>::value, int> = 0>
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