Reducing functions¶
xtensor provides the following reducing functions for xexpressions:
Defined in xtensor/xmath.hpp

template <class E, class X, class EVS = evaluation_strategy::lazy, class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value, int>>
autoxt
::
sum
(E &&e, X &&axes, EVS es = EVS()) Sum of elements over given axes.
Returns an xreducer for the sum of elements over given axes.
 Return
 an xreducer
 Parameters
e
: an xexpressionaxes
: the axes along which the sum is performed (optional)es
: evaluation strategy of the reducer

template <class E, class X, class EVS = evaluation_strategy::lazy, class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value, int>>
autoxt
::
prod
(E &&e, X &&axes, EVS es = EVS()) Product of elements over given axes.
Returns an xreducer for the product of elements over given axes.
 Return
 an xreducer
 Parameters
e
: an xexpressionaxes
: the axes along which the product is computed (optional)es
: evaluation strategy of the reducer

template <class E, class X>
autoxt
::
mean
(E &&e, X &&axes) Mean of elements over given axes.
Returns an xreducer for the mean of elements over given axes.
 Return
 an xexpression
 Parameters
e
: an xexpressionaxes
: the axes along which the mean is computed (optional)

template <class T>
autoxt
::
diff
(const xexpression<T> &a, std::size_t n = 1, std::ptrdiff_t axis = 1)¶ Calculate the nth discrete difference along the given axis.
Calculate the nth discrete difference along the given axis. This function is not lazy (might change in the future).
 Return
 an xarray
 Parameters
a
: an xexpressionn
: The number of times values are differenced. If zero, the input is returned asis. (optional)axis
: The axis along which the difference is taken, default is the last axis.

template <class T>
autoxt
::
trapz
(const xexpression<T> &y, double dx = 1.0, std::ptrdiff_t axis = 1) Integrate along the given axis using the composite trapezoidal rule.
Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change in the future).
 Return
 an xarray
 Parameters
y
: an xexpressiondx
: the spacing between sample points (optional)axis
: the axis along which to integrate.

template <class T, class E>
autoxt
::
trapz
(const xexpression<T> &y, const xexpression<E> &x, std::ptrdiff_t axis = 1)¶ Integrate along the given axis using the composite trapezoidal rule.
Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change in the future).
 Return
 an xarray
 Parameters
y
: an xexpressionx
: an xexpression representing the sample points corresponding to the y values.axis
: the axis along which to integrate.
Defined in xtensor/xnorm.hpp

template <class E, class X, class EVS, class>
autoxt
::
norm_l0
(E &&e, X &&axes, EVS es)¶ L0 (count) pseudonorm of an arraylike argument over given axes.
Returns an xreducer for the L0 pseudonorm of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionaxes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class X, class EVS, class>
autoxt
::
norm_l1
(E &&e, X &&axes, EVS es)¶ L1 norm of an arraylike argument over given axes.
Returns an xreducer for the L1 norm of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionaxes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class X, class EVS, class>
autoxt
::
norm_sq
(E &&e, X &&axes, EVS es)¶ Squared L2 norm of an arraylike argument over given axes.
Returns an xreducer for the squared L2 norm of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionaxes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class X, class EVS = evaluation_strategy::lazy, typename = concept_check <is_xexpression<E>::value>, class = disable_evaluation_strategy<X>>
autoxt
::
norm_l2
(E &&e, X &&axes, EVS es = EVS())¶ L2 norm of an arraylike argument over given axes.
Returns an xreducer for the L2 norm of the elements across given axes.
 Return
 an xreducer (specifically:
sqrt(norm_sq(e, axes))
) (or xcontainer, depending on evaluation strategy)  Parameters
e
: an xexpressiones
: evaluation strategy to use (lazy (default), or immediate)axes
: the axes along which the norm is computed

template <class E, class X, class EVS, class>
autoxt
::
norm_linf
(E &&e, X &&axes, EVS es)¶ Infinity (maximum) norm of an arraylike argument over given axes.
Returns an xreducer for the infinity norm of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionaxes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class X, class EVS = evaluation_strategy::lazy, class = disable_evaluation_strategy<X>>
autoxt
::
norm_lp_to_p
(E &&e, double p, X &&axes, EVS es = EVS()) pth power of the Lp norm of an arraylike argument over given axes.
Returns an xreducer for the pth power of the Lp norm of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionp
:axes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class X, class EVS = evaluation_strategy::lazy, class = disable_evaluation_strategy<X>>
autoxt
::
norm_lp
(E &&e, double p, X &&axes, EVS es = EVS()) Lp norm of an arraylike argument over given axes.
Returns an xreducer for the Lp norm (p != 0) of the elements across given axes.
 Return
 an xreducer (or xcontainer, depending on evaluation strategy) When no axes are provided, the norm is calculated over the entire array. In this case, the reducer represents a scalar result, otherwise an array of appropriate dimension.
 Parameters
e
: an xexpressionp
:axes
: the axes along which the norm is computed (optional)es
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class EVS = evaluation_strategy::lazy, typename = concept_check <is_xexpression<E>::value>>
autoxt
::
norm_induced_l1
(E &&e, EVS es = EVS())¶ Induced L1 norm of a matrix.
Returns an xreducer for the induced L1 norm (i.e. the maximum of the L1 norms of e’s columns).
 Return
 an xreducer (or xcontainer, depending on evaluation strategy)
 Parameters
e
: a 2D xexpressiones
: evaluation strategy to use (lazy (default), or immediate)

template <class E, class EVS = evaluation_strategy::lazy, typename = concept_check <is_xexpression<E>::value>>
autoxt
::
norm_induced_linf
(E &&e, EVS es = EVS())¶ Induced Linfinity norm of a matrix.
Returns an xreducer for the induced Linfinity norm (i.e. the maximum of the L1 norms of e’s rows).
 Return
 an xreducer (or xcontainer, depending on evaluation strategy)
 Parameters
e
: a 2D xexpressiones
: evaluation strategy to use (lazy (default), or immediate)