10#ifndef XTENSOR_FUNCTION_HPP
11#define XTENSOR_FUNCTION_HPP
21#include <xtl/xsequence.hpp>
22#include <xtl/xtype_traits.hpp>
24#include "../containers/xscalar.hpp"
25#include "../core/xaccessible.hpp"
26#include "../core/xexpression_traits.hpp"
27#include "../core/xiterable.hpp"
28#include "../core/xiterator.hpp"
29#include "../core/xlayout.hpp"
30#include "../core/xshape.hpp"
31#include "../core/xstrides.hpp"
32#include "../utils/xtensor_simd.hpp"
33#include "../utils/xutils.hpp"
41 using conjunction_c = std::conjunction<std::integral_constant<bool, B>...>;
47 template <
class S,
class is_shape_trivial>
48 struct xfunction_cache_impl
54 xfunction_cache_impl()
55 : shape(xtl::make_sequence<S>(0, std::size_t(0)))
57 , is_initialized(false)
62 template <std::size_t... N,
class is_shape_trivial>
63 struct xfunction_cache_impl<fixed_shape<N...>, is_shape_trivial>
65 XTENSOR_CONSTEXPR_ENHANCED_STATIC fixed_shape<N...> shape = fixed_shape<N...>();
66 XTENSOR_CONSTEXPR_ENHANCED_STATIC
bool is_trivial = is_shape_trivial::value;
67 XTENSOR_CONSTEXPR_ENHANCED_STATIC
bool is_initialized =
true;
70 template <
class... CT>
71 struct xfunction_bool_load_type
73 using type = xtl::promote_type_t<typename std::decay_t<CT>::bool_load_type...>;
77 struct xfunction_bool_load_type<CT>
79 using type =
typename std::decay_t<CT>::bool_load_type;
82 template <
class... CT>
83 using xfunction_bool_load_type_t =
typename xfunction_bool_load_type<CT...>::type;
93 template <
class Tag,
class F,
class... CT>
96 template <
class F,
class... CT>
102 template <
class F,
class... CT>
107 template <
class F,
class... CT>
111 template <
class promote>
112 struct xfunction_cache : detail::xfunction_cache_impl<typename promote::type, promote>
116 template <
class F,
class... CT>
119 template <
class F,
class... CT>
122 template <
class F,
class... CT>
125 template <
class F,
class... CT>
128 using inner_shape_type = promote_shape_t<typename std::decay_t<CT>::shape_type...>;
130 using stepper = const_stepper;
133 template <
class F,
class... CT>
138 decltype(std::declval<F>()(std::declval<xvalue_type_t<std::decay_t<CT>>>()...))>::type;
139 using value_type = std::decay_t<func_return_type>;
140 using reference = func_return_type;
141 using const_reference = reference;
142 using size_type = common_size_type_t<std::decay_t<CT>...>;
145 template <
class T,
class F,
class... CT>
148 has_simd_apply<F, xt_simd::simd_type<T>>,
149 has_simd_interface<std::decay_t<CT>, T>...>
160 std::enable_if_t<!has_memory_address<E>::value && is_specialization_of<xfunction, E>::value>>
162 template <std::size_t I = 0,
class... T, std::enable_if_t<(I ==
sizeof...(T)),
int> = 0>
163 static bool check_tuple(
const std::tuple<T...>&,
const memory_range&)
168 template <std::size_t I = 0,
class... T, std::enable_if_t<(I <
sizeof...(T)),
int> = 0>
169 static bool check_tuple(
const std::tuple<T...>& t,
const memory_range& dst_range)
171 using ChildE = std::decay_t<decltype(std::get<I>(t))>;
172 return overlapping_memory_checker_traits<ChildE>::check_overlap(std::get<I>(t), dst_range)
173 || check_tuple<I + 1>(t, dst_range);
176 static bool check_overlap(
const E& expr,
const memory_range& dst_range)
178 if (expr.size() == 0)
184 return check_tuple(expr.arguments(), dst_range);
204 template <
class F,
class... CT>
206 public xsharable_expression<xfunction<F, CT...>>,
207 private xconst_accessible<xfunction<F, CT...>>,
208 public extension::xfunction_base_t<F, CT...>
213 using accessible_base = xconst_accessible<self_type>;
214 using extension_base = extension::xfunction_base_t<F, CT...>;
215 using expression_tag =
typename extension_base::expression_tag;
216 using only_scalar = all_xscalar<CT...>;
217 using functor_type =
typename std::remove_reference<F>::type;
218 using tuple_type = std::tuple<CT...>;
221 using value_type =
typename inner_types::value_type;
222 using reference =
typename inner_types::reference;
223 using const_reference =
typename inner_types::const_reference;
224 using pointer = value_type*;
225 using const_pointer =
const value_type*;
226 using size_type =
typename inner_types::size_type;
227 using difference_type = common_difference_type_t<std::decay_t<CT>...>;
229 using simd_value_type = xt_simd::simd_type<value_type>;
232 using bool_load_type = detail::xfunction_bool_load_type_t<CT...>;
234 template <
class requested_type>
235 using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
238 using inner_shape_type =
typename iterable_base::inner_shape_type;
239 using shape_type = inner_shape_type;
241 using stepper =
typename iterable_base::stepper;
242 using const_stepper =
typename iterable_base::const_stepper;
247 template <layout_type L>
248 using layout_iterator =
typename iterable_base::template layout_iterator<L>;
249 template <layout_type L>
250 using const_layout_iterator =
typename iterable_base::template const_layout_iterator<L>;
251 template <layout_type L>
252 using reverse_layout_iterator =
typename iterable_base::template reverse_layout_iterator<L>;
253 template <layout_type L>
254 using const_reverse_layout_iterator =
typename iterable_base::template const_reverse_layout_iterator<L>;
256 template <
class S, layout_type L>
257 using broadcast_iterator =
typename iterable_base::template broadcast_iterator<S, L>;
258 template <
class S, layout_type L>
259 using const_broadcast_iterator =
typename iterable_base::template const_broadcast_iterator<S, L>;
260 template <
class S, layout_type L>
261 using reverse_broadcast_iterator =
typename iterable_base::template reverse_broadcast_iterator<S, L>;
262 template <
class S, layout_type L>
263 using const_reverse_broadcast_iterator =
typename iterable_base::template const_reverse_broadcast_iterator<S, L>;
266 using linear_iterator = const_linear_iterator;
267 using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>;
268 using reverse_linear_iterator = std::reverse_iterator<linear_iterator>;
270 using iterator =
typename iterable_base::iterator;
271 using const_iterator =
typename iterable_base::const_iterator;
272 using reverse_iterator =
typename iterable_base::reverse_iterator;
273 using const_reverse_iterator =
typename iterable_base::const_reverse_iterator;
275 template <
class Func,
class... CTA,
class U = std::enable_if_t<!std::is_base_of<std::decay_t<Func>, self_type>::value>>
278 template <
class FA,
class... CTA>
291 const inner_shape_type&
shape() const;
293 bool is_contiguous() const noexcept;
294 using accessible_base::
shape;
296 template <class... Args>
297 const_reference operator()(Args... args) const;
299 template <class... Args>
300 const_reference unchecked(Args... args) const;
302 using accessible_base::at;
303 using accessible_base::operator[];
304 using accessible_base::
back;
305 using accessible_base::
front;
307 using accessible_base::periodic;
310 const_reference element(It first, It last) const;
318 using iterable_base::begin;
319 using iterable_base::cbegin;
320 using iterable_base::cend;
321 using iterable_base::crbegin;
322 using iterable_base::crend;
323 using iterable_base::end;
324 using iterable_base::rbegin;
325 using iterable_base::rend;
327 const_linear_iterator linear_begin() const noexcept;
328 const_linear_iterator linear_end() const noexcept;
329 const_linear_iterator linear_cbegin() const noexcept;
330 const_linear_iterator linear_cend() const noexcept;
332 const_reverse_linear_iterator linear_rbegin() const noexcept;
333 const_reverse_linear_iterator linear_rend() const noexcept;
334 const_reverse_linear_iterator linear_crbegin() const noexcept;
335 const_reverse_linear_iterator linear_crend() const noexcept;
338 const_stepper stepper_begin(const S&
shape) const noexcept;
342 const_reference data_element(size_type i) const;
344 const_reference
flat(size_type i) const;
346 template <class UT = self_type, class = typename std::enable_if<UT::only_scalar::value>::type>
347 operator value_type() const;
349 template <class align, class requested_type = value_type, std::
size_t N = xt_simd::simd_traits<requested_type>::
size>
350 simd_return_type<requested_type> load_simd(size_type i) const;
352 const tuple_type& arguments() const noexcept;
354 const functor_type& functor() const noexcept;
358 template <std::
size_t... I>
359 layout_type layout_impl(std::index_sequence<I...>) const noexcept;
361 template <std::
size_t... I, class... Args>
362 const_reference access_impl(std::index_sequence<I...>, Args... args) const;
364 template <std::
size_t... I, class... Args>
365 const_reference unchecked_impl(std::index_sequence<I...>, Args... args) const;
367 template <std::
size_t... I, class It>
368 const_reference element_access_impl(std::index_sequence<I...>, It first, It last) const;
370 template <std::
size_t... I>
371 const_reference data_element_impl(std::index_sequence<I...>, size_type i) const;
373 template <class align, class requested_type, std::
size_t N, std::
size_t... I>
374 auto load_simd_impl(std::index_sequence<I...>, size_type i) const;
376 template <class Func, std::
size_t... I>
377 const_stepper build_stepper(Func&& f, std::index_sequence<I...>) const noexcept;
379 template <class Func, std::
size_t... I>
380 auto build_iterator(Func&& f, std::index_sequence<I...>) const noexcept;
382 size_type compute_dimension() const noexcept;
384 void compute_cached_shape() const;
388 mutable
xfunction_cache<detail::promote_index<typename std::decay_t<CT>::shape_type...>> m_cache;
393 friend class xconst_accessible<self_type>;
400 template <class F, class... CT>
401 class xfunction_iterator : public xtl::xrandom_access_iterator_base<
402 xfunction_iterator<F, CT...>,
403 typename
xfunction<F, CT...>::value_type,
404 typename
xfunction<F, CT...>::difference_type,
410 using self_type = xfunction_iterator<F, CT...>;
411 using functor_type =
typename std::remove_reference<F>::type;
412 using xfunction_type =
xfunction<F, CT...>;
414 using value_type =
typename xfunction_type::value_type;
415 using reference =
typename xfunction_type::value_type;
416 using pointer =
typename xfunction_type::const_pointer;
417 using difference_type =
typename xfunction_type::difference_type;
418 using iterator_category = std::random_access_iterator_tag;
420 template <
class... It>
421 xfunction_iterator(
const xfunction_type* func, It&&... it)
noexcept;
423 self_type& operator++();
424 self_type& operator--();
426 self_type& operator+=(difference_type n);
427 self_type& operator-=(difference_type n);
429 difference_type
operator-(
const self_type& rhs)
const;
433 bool equal(
const self_type& rhs)
const;
434 bool less_than(
const self_type& rhs)
const;
438 using data_type = std::tuple<
decltype(xt::linear_begin(std::declval<
const std::decay_t<CT>>()))...>;
440 template <std::size_t... I>
441 reference deref_impl(std::index_sequence<I...>)
const;
443 template <std::size_t... I>
445 tuple_max_diff(std::index_sequence<I...>,
const data_type& lhs,
const data_type& rhs)
const;
447 const xfunction_type* p_f;
451 template <
class F,
class... CT>
454 template <
class F,
class... CT>
461 template <
class F,
class... CT>
462 class xfunction_stepper
466 using self_type = xfunction_stepper<F, CT...>;
467 using functor_type =
typename std::remove_reference<F>::type;
468 using xfunction_type =
xfunction<F, CT...>;
470 using value_type =
typename xfunction_type::value_type;
471 using reference =
typename xfunction_type::reference;
472 using pointer =
typename xfunction_type::const_pointer;
473 using size_type =
typename xfunction_type::size_type;
474 using difference_type =
typename xfunction_type::difference_type;
476 using shape_type =
typename xfunction_type::shape_type;
478 template <
class requested_type>
479 using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
481 template <
class... St>
482 xfunction_stepper(
const xfunction_type* func, St&&... st)
noexcept;
484 void step(size_type dim);
485 void step_back(size_type dim);
486 void step(size_type dim, size_type n);
487 void step_back(size_type dim, size_type n);
488 void reset(size_type dim);
489 void reset_back(size_type dim);
494 reference operator*()
const;
497 simd_return_type<T> step_simd();
503 template <std::size_t... I>
504 reference deref_impl(std::index_sequence<I...>)
const;
506 template <
class T, std::size_t... I>
507 simd_return_type<T> step_simd_impl(std::index_sequence<I...>);
509 const xfunction_type* p_f;
510 std::tuple<typename std::decay_t<CT>::const_stepper...> m_st;
527 template <
class F,
class... CT>
528 template <
class Func,
class... CTA,
class U>
530 : m_e(std::forward<CTA>(e)...)
531 , m_f(std::forward<Func>(f))
540 template <
class F,
class... CT>
541 template <
class FA,
class... CTA>
543 : m_e(xf.arguments())
557 template <
class F,
class... CT>
560 size_type
dimension = m_cache.is_initialized ? m_cache.shape.size() : compute_dimension();
564 template <
class F,
class... CT>
565 inline void xfunction<F, CT...>::compute_cached_shape()
const
567 static_assert(!detail::is_fixed<shape_type>::value,
"Calling compute_cached_shape on fixed!");
569 m_cache.shape = uninitialized_shape<xindex_type_t<inner_shape_type>>(compute_dimension());
571 m_cache.is_initialized =
true;
577 template <
class F,
class... CT>
580 if constexpr (!detail::is_fixed<inner_shape_type>::value)
582 if (!m_cache.is_initialized)
584 compute_cached_shape();
587 return m_cache.
shape;
593 template <
class F,
class... CT>
596 return layout_impl(std::make_index_sequence<
sizeof...(CT)>());
599 template <
class F,
class... CT>
600 inline bool xfunction<F, CT...>::is_contiguous() const noexcept
604 [](
bool r,
const auto&
exp)
606 return r &&
exp.is_contiguous();
625 template <
class F,
class... CT>
626 template <
class... Args>
627 inline auto xfunction<F, CT...>::operator()(Args... args)
const -> const_reference
631 return access_impl(std::make_index_sequence<
sizeof...(CT)>(),
static_cast<size_type
>(args)...);
643 template <
class F,
class... CT>
646 return data_element_impl(std::make_index_sequence<
sizeof...(CT)>(), index);
668 template <
class F,
class... CT>
669 template <
class... Args>
670 inline auto xfunction<F, CT...>::unchecked(Args... args)
const -> const_reference
674 return unchecked_impl(std::make_index_sequence<
sizeof...(CT)>(),
static_cast<size_type
>(args)...);
684 template <
class F,
class... CT>
686 inline auto xfunction<F, CT...>::element(It first, It last)
const -> const_reference
688 return element_access_impl(std::make_index_sequence<
sizeof...(CT)>(), first, last);
703 template <
class F,
class... CT>
707 if (m_cache.is_initialized && reuse_cache)
709 std::copy(m_cache.shape.cbegin(), m_cache.shape.cend(),
shape.begin());
710 return m_cache.is_trivial;
715 auto func = [&
shape](
bool b,
auto&& e)
717 return e.broadcast_shape(
shape) && b;
728 template <
class F,
class... CT>
732 auto func = [&
strides](
bool b,
auto&& e)
734 return b && e.has_linear_assign(
strides);
741 template <
class F,
class... CT>
742 inline auto xfunction<F, CT...>::linear_begin() const noexcept -> const_linear_iterator
744 return linear_cbegin();
747 template <
class F,
class... CT>
748 inline auto xfunction<F, CT...>::linear_end() const noexcept -> const_linear_iterator
750 return linear_cend();
753 template <
class F,
class... CT>
756 auto f = [](
const auto& e)
noexcept
758 return xt::linear_begin(e);
760 return build_iterator(f, std::make_index_sequence<
sizeof...(CT)>());
763 template <
class F,
class... CT>
766 auto f = [](
const auto& e)
noexcept
768 return xt::linear_end(e);
770 return build_iterator(f, std::make_index_sequence<
sizeof...(CT)>());
773 template <
class F,
class... CT>
776 return linear_crbegin();
779 template <
class F,
class... CT>
782 return linear_crend();
785 template <
class F,
class... CT>
788 return const_reverse_linear_iterator(linear_cend());
791 template <
class F,
class... CT>
794 return const_reverse_linear_iterator(linear_cbegin());
797 template <
class F,
class... CT>
801 auto f = [&
shape](
const auto& e)
noexcept
803 return e.stepper_begin(
shape);
805 return build_stepper(f, std::make_index_sequence<
sizeof...(CT)>());
808 template <
class F,
class... CT>
812 auto f = [&
shape, l](
const auto& e)
noexcept
814 return e.stepper_end(
shape, l);
816 return build_stepper(f, std::make_index_sequence<
sizeof...(CT)>());
819 template <
class F,
class... CT>
822 return data_element_impl(std::make_index_sequence<
sizeof...(CT)>(), i);
825 template <
class F,
class... CT>
826 template <
class UT,
class>
827 inline xfunction<F, CT...>::operator value_type()
const
832 template <
class F,
class... CT>
833 template <
class align,
class requested_type, std::
size_t N>
836 return load_simd_impl<align, requested_type, N>(std::make_index_sequence<
sizeof...(CT)>(), i);
839 template <
class F,
class... CT>
845 template <
class F,
class... CT>
851 template <
class F,
class... CT>
852 template <std::size_t... I>
858 template <
class F,
class... CT>
859 template <std::size_t... I,
class... Args>
863 XTENSOR_TRY(check_index(
shape(), args...));
864 XTENSOR_CHECK_DIMENSION(
shape(), args...);
865 return m_f(std::get<I>(m_e)(args...)...);
868 template <
class F,
class... CT>
869 template <std::size_t... I,
class... Args>
873 return m_f(std::get<I>(m_e).unchecked(args...)...);
876 template <
class F,
class... CT>
877 template <std::size_t... I,
class It>
881 XTENSOR_TRY(check_element_index(
shape(), first, last));
882 return m_f((std::get<I>(m_e).element(first, last))...);
885 template <
class F,
class... CT>
886 template <std::size_t... I>
890 return m_f((std::get<I>(m_e).data_element(i))...);
893 template <
class F,
class... CT>
894 template <
class align,
class requested_type, std::size_t N, std::size_t... I>
897 return m_f.simd_apply((std::get<I>(m_e).
template load_simd<align, requested_type>(i))...);
900 template <
class F,
class... CT>
901 template <
class Func, std::size_t... I>
905 return const_stepper(
this, f(std::get<I>(m_e))...);
908 template <
class F,
class... CT>
909 template <
class Func, std::size_t... I>
912 return const_linear_iterator(
this, f(std::get<I>(m_e))...);
915 template <
class F,
class... CT>
918 auto func = [](size_type d,
auto&& e)
noexcept
920 return (std::max)(d, e.dimension());
929 template <
class F,
class... CT>
930 template <
class... It>
931 inline xfunction_iterator<F, CT...>::xfunction_iterator(
const xfunction_type* func, It&&... it) noexcept
933 , m_it(std::forward<It>(it)...)
937 template <
class F,
class... CT>
938 inline auto xfunction_iterator<F, CT...>::operator++() -> self_type&
940 auto f = [](
auto& it)
948 template <
class F,
class... CT>
949 inline auto xfunction_iterator<F, CT...>::operator--() -> self_type&
951 auto f = [](
auto& it)
959 template <
class F,
class... CT>
960 inline auto xfunction_iterator<F, CT...>::operator+=(difference_type n) -> self_type&
962 auto f = [n](
auto& it)
970 template <
class F,
class... CT>
971 inline auto xfunction_iterator<F, CT...>::operator-=(difference_type n) -> self_type&
973 auto f = [n](
auto& it)
981 template <
class F,
class... CT>
982 inline auto xfunction_iterator<F, CT...>::operator-(
const self_type& rhs)
const -> difference_type
984 return tuple_max_diff(std::make_index_sequence<
sizeof...(CT)>(), m_it, rhs.m_it);
987 template <
class F,
class... CT>
988 inline auto xfunction_iterator<F, CT...>::operator*() const -> reference
990 return deref_impl(std::make_index_sequence<
sizeof...(CT)>());
993 template <
class F,
class... CT>
994 inline bool xfunction_iterator<F, CT...>::equal(
const self_type& rhs)
const
998 constexpr std::size_t temp = xtl::mpl::find_if<is_not_xdummy_iterator, data_type>::value;
999 constexpr std::size_t index = (temp == std::tuple_size<data_type>::value) ? 0 : temp;
1000 return std::get<index>(m_it) == std::get<index>(rhs.m_it);
1003 template <
class F,
class... CT>
1004 inline bool xfunction_iterator<F, CT...>::less_than(
const self_type& rhs)
const
1008 constexpr std::size_t temp = xtl::mpl::find_if<is_not_xdummy_iterator, data_type>::value;
1009 constexpr std::size_t index = (temp == std::tuple_size<data_type>::value) ? 0 : temp;
1010 return std::get<index>(m_it) < std::get<index>(rhs.m_it);
1013 template <
class F,
class... CT>
1014 template <std::size_t... I>
1015 inline auto xfunction_iterator<F, CT...>::deref_impl(std::index_sequence<I...>)
const -> reference
1017 return (p_f->m_f)(*std::get<I>(m_it)...);
1020 template <
class F,
class... CT>
1021 template <std::size_t... I>
1022 inline auto xfunction_iterator<F, CT...>::tuple_max_diff(
1023 std::index_sequence<I...>,
1024 const data_type& lhs,
1025 const data_type& rhs
1026 )
const -> difference_type
1028 auto diff = std::make_tuple((std::get<I>(lhs) - std::get<I>(rhs))...);
1029 auto func = [](difference_type n,
auto&& v)
1031 return (std::max)(n, v);
1036 template <
class F,
class... CT>
1037 inline bool operator==(
const xfunction_iterator<F, CT...>& it1,
const xfunction_iterator<F, CT...>& it2)
1039 return it1.equal(it2);
1042 template <
class F,
class... CT>
1043 inline bool operator<(
const xfunction_iterator<F, CT...>& it1,
const xfunction_iterator<F, CT...>& it2)
1045 return it1.less_than(it2);
1052 template <
class F,
class... CT>
1053 template <
class... St>
1054 inline xfunction_stepper<F, CT...>::xfunction_stepper(
const xfunction_type* func, St&&... st) noexcept
1056 , m_st(std::forward<St>(st)...)
1060 template <
class F,
class... CT>
1061 inline void xfunction_stepper<F, CT...>::step(size_type dim)
1063 auto f = [dim](
auto& st)
1070 template <
class F,
class... CT>
1071 inline void xfunction_stepper<F, CT...>::step_back(size_type dim)
1073 auto f = [dim](
auto& st)
1080 template <
class F,
class... CT>
1081 inline void xfunction_stepper<F, CT...>::step(size_type dim, size_type n)
1083 auto f = [dim, n](
auto& st)
1090 template <
class F,
class... CT>
1091 inline void xfunction_stepper<F, CT...>::step_back(size_type dim, size_type n)
1093 auto f = [dim, n](
auto& st)
1095 st.step_back(dim, n);
1100 template <
class F,
class... CT>
1101 inline void xfunction_stepper<F, CT...>::reset(size_type dim)
1103 auto f = [dim](
auto& st)
1110 template <
class F,
class... CT>
1111 inline void xfunction_stepper<F, CT...>::reset_back(size_type dim)
1113 auto f = [dim](
auto& st)
1120 template <
class F,
class... CT>
1121 inline void xfunction_stepper<F, CT...>::to_begin()
1123 auto f = [](
auto& st)
1130 template <
class F,
class... CT>
1131 inline void xfunction_stepper<F, CT...>::to_end(
layout_type l)
1133 auto f = [l](
auto& st)
1140 template <
class F,
class... CT>
1141 inline auto xfunction_stepper<F, CT...>::operator*() const -> reference
1143 return deref_impl(std::make_index_sequence<
sizeof...(CT)>());
1146 template <
class F,
class... CT>
1147 template <std::size_t... I>
1148 inline auto xfunction_stepper<F, CT...>::deref_impl(std::index_sequence<I...>)
const -> reference
1150 return (p_f->m_f)(*std::get<I>(m_st)...);
1153 template <
class F,
class... CT>
1154 template <
class T, std::size_t... I>
1155 inline auto xfunction_stepper<F, CT...>::step_simd_impl(std::index_sequence<I...>) -> simd_return_type<T>
1157 return (p_f->m_f.simd_apply)(std::get<I>(m_st).template step_simd<T>()...);
1160 template <
class F,
class... CT>
1162 inline auto xfunction_stepper<F, CT...>::step_simd() -> simd_return_type<T>
1164 return step_simd_impl<T>(std::make_index_sequence<
sizeof...(CT)>());
1167 template <
class F,
class... CT>
1168 inline void xfunction_stepper<F, CT...>::step_leading()
1170 auto step_leading_lambda = [](
auto&& st)
1174 for_each(step_leading_lambda, m_st);
size_type size() const noexcept
Base class for multidimensional iterable constant expressions.
Multidimensional function operating on xtensor expressions.
const_reference back() const
xfunction(xfunction< FA, CTA... > xf) noexcept
Constructs an xfunction applying the specified function given by another xfunction with its arguments...
bool in_bounds(Args... args) const
size_type size() const noexcept
bool broadcast_shape(S &shape, bool reuse_cache=false) const
layout_type layout() const noexcept
const inner_shape_type & shape() const
size_type dimension() const noexcept
Returns the number of dimensions of the function.
xfunction(Func &&f, CTA &&... e) noexcept
Constructs an xfunction applying the specified function to the given arguments.
bool has_linear_assign(const S &strides) const noexcept
const_reference flat(size_type i) const
const_reference front() const
auto operator-(E &&e) noexcept -> detail::xfunction_type_t< detail::negate, E >
Opposite.
auto operator*(E1 &&e1, E2 &&e2) noexcept -> detail::xfunction_type_t< detail::multiplies, E1, E2 >
Multiplication.
auto equal(E1 &&e1, E2 &&e2) noexcept -> detail::xfunction_type_t< detail::equal_to, E1, E2 >
Element-wise equality.
auto exp(E &&e) noexcept -> detail::xfunction_type_t< math::exp_fun, E >
Natural exponential function.
auto diff(const xexpression< T > &a, std::size_t n=1, std::ptrdiff_t axis=-1)
Calculate the n-th discrete difference along the given axis.
auto strides(const E &e, stride_type type=stride_type::normal) noexcept
Get strides of an object.
standard mathematical functions for xexpressions
constexpr layout_type compute_layout(Args... args) noexcept
Implementation of the following logical table:
auto accumulate(F &&f, E &&e, EVS evaluation_strategy=EVS())
Accumulate and flatten array NOTE This function is not lazy!