# Reducing functions

xtensor provides the following reducing functions for xexpressions:

Defined in `xtensor/core/xmath.hpp`

template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0>
inline auto xt::sum(E &&e, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “sum” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto sum(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto sum(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto sum(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto sum(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto sum(E &&e, EVS es = EVS())
    - template<class T = void, class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto sum(E &&e, const I (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>> = 0> auto sum(E &&e, X axis, EVS es = EVS())

template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0>
inline auto xt::prod(E &&e, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “prod” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto prod(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto prod(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto prod(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto prod(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto prod(E &&e, EVS es = EVS())
    - template<class T = void, class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto prod(E &&e, const I (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>> = 0> auto prod(E &&e, X axis, EVS es = EVS())

template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0>
inline auto xt::mean(E &&e, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “mean” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto mean(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto mean(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto mean(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto mean(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto mean(E &&e, EVS es = EVS())
    - template<class T = void, class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto mean(E &&e, const I (&axes)[N], EVS es = EVS())

Warning

doxygenfunction: Cannot find function “average” in doxygen xml output for project “xtensor” from directory: ../xml

Warning

doxygenfunction: Unable to resolve function “variance” with arguments (E&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class A, std::size_t N, class D, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto variance(E &&e, const A (&axes)[N], const D &ddof, EVS es = EVS())
    - template<class T = void, class E, class A, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto variance(E &&e, const A (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto variance(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto variance(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto variance(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto variance(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>> = 0> auto variance(E &&e, X &&axes, EVS es = EVS())

template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>> = 0>
inline auto xt::variance(E &&e, X &&axes, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “variance” with arguments (E&&, X&&, const D&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class A, std::size_t N, class D, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto variance(E &&e, const A (&axes)[N], const D &ddof, EVS es = EVS())
    - template<class T = void, class E, class A, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto variance(E &&e, const A (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto variance(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto variance(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto variance(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto variance(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>> = 0> auto variance(E &&e, X &&axes, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “stddev” with arguments (E&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class A, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto stddev(E &&e, const A (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto stddev(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto stddev(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto stddev(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto stddev(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Unable to resolve function “stddev” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class A, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto stddev(E &&e, const A (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto stddev(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto stddev(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto stddev(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto stddev(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Cannot find function “diff” in doxygen xml output for project “xtensor” from directory: ../xml

template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0>
inline auto xt::amax(E &&e, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “amax” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto amax(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto amax(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto amax(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto amax(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto amax(E &&e, EVS es = EVS())
    - template<class T = void, class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto amax(E &&e, const I (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>> = 0> auto amax(E &&e, X axis, EVS es = EVS())

template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0>
inline auto xt::amin(E &&e, EVS es = EVS())

Warning

doxygenfunction: Unable to resolve function “amin” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class T = void, class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto amin(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class T = void, class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto amin(E &&e, BS &&block_shape, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto amin(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class T = void, class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto amin(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class T = void, class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<EVS>> = 0> auto amin(E &&e, EVS es = EVS())
    - template<class T = void, class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto amin(E &&e, const I (&axes)[N], EVS es = EVS())
    - template<class T = void, class E, class X, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>> = 0> auto amin(E &&e, X axis, EVS es = EVS())

Warning

doxygenfunction: Cannot find function “trapz” in doxygen xml output for project “xtensor” from directory: ../xml

Warning

doxygenfunction: Cannot find function “trapz” in doxygen xml output for project “xtensor” from directory: ../xml

Defined in `xtensor/reducers/xnorm.hpp`

Warning

doxygenfunction: Unable to resolve function “norm_l0” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_l0(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_l0(E &&e, BS &&block_shape, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_l0(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_l0(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Unable to resolve function “norm_l1” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_l1(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_l1(E &&e, BS &&block_shape, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_l1(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_l1(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Unable to resolve function “norm_sq” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_sq(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_sq(E &&e, BS &&block_shape, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_sq(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_sq(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Unable to resolve function “norm_l2” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_l2(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_l2(E &&e, BS &&block_shape, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_l2(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_l2(E &&e, BS &&block_shape, X axis, O options = O())
    - template<class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto norm_l2(E &&e, const I (&axes)[N], EVS es = EVS()) noexcept

Warning

doxygenfunction: Unable to resolve function “norm_linf” with arguments (E&&, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_linf(E &&e, BS &&block_shape, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_linf(E &&e, BS &&block_shape, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_linf(E &&e, BS &&block_shape, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_linf(E &&e, BS &&block_shape, X axis, O options = O())

Warning

doxygenfunction: Unable to resolve function “norm_lp_to_p” with arguments (E&&, double, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_lp_to_p(E &&e, BS &&block_shape, double p, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_lp_to_p(E &&e, BS &&block_shape, double p, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_lp_to_p(E &&e, BS &&block_shape, double p, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_lp_to_p(E &&e, BS &&block_shape, double p, X axis, O options = O())
    - template<class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_xexpression<E>> = 0> auto norm_lp_to_p(E &&e, double p, EVS es = EVS()) noexcept
    - template<class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto norm_lp_to_p(E &&e, double p, const I (&axes)[N], EVS es = EVS()) noexcept

Warning

doxygenfunction: Unable to resolve function “norm_lp” with arguments (E&&, double, X&&, EVS) in doxygen xml output for project “xtensor” from directory: ../xml. Potential matches:

    - template<class E, class BS, class I, std::size_t N, class O = std::tuple<evaluation_strategy::lazy_type>> auto norm_lp(E &&e, BS &&block_shape, double p, const I (&axes)[N], O options = O())
    - template<class E, class BS, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>> = 0> auto norm_lp(E &&e, BS &&block_shape, double p, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>> = 0> auto norm_lp(E &&e, BS &&block_shape, double p, X &&axes, O options = O())
    - template<class E, class BS, class X, class O = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<xtl::is_integral<std::decay_t<X>>> = 0> auto norm_lp(E &&e, BS &&block_shape, double p, X axis, O options = O())
    - template<class E, class EVS = std::tuple<evaluation_strategy::lazy_type>, xtl::check_concept<is_xexpression<E>> = 0> auto norm_lp(E &&e, double p, EVS es = EVS())
    - template<class E, class I, std::size_t N, class EVS = std::tuple<evaluation_strategy::lazy_type>> auto norm_lp(E &&e, double p, const I (&axes)[N], EVS es = EVS())

Warning

doxygenfunction: Cannot find function “norm_induced_l1” in doxygen xml output for project “xtensor” from directory: ../xml

Warning

doxygenfunction: Cannot find function “norm_induced_linf” in doxygen xml output for project “xtensor” from directory: ../xml