10#ifndef XTENSOR_STRIDED_VIEW_HPP
11#define XTENSOR_STRIDED_VIEW_HPP
19#include <xtl/xsequence.hpp>
21#include "../containers/xstorage.hpp"
22#include "../core/xexpression.hpp"
23#include "../core/xiterable.hpp"
24#include "../core/xlayout.hpp"
25#include "../core/xsemantic.hpp"
26#include "../utils/xutils.hpp"
27#include "../views/xstrided_view_base.hpp"
37 template <
class Tag,
class CT,
class S, layout_type L,
class FST>
40 template <
class CT,
class S, layout_type L,
class FST>
46 template <
class CT,
class S, layout_type L,
class FST>
51 template <
class CT,
class S, layout_type L,
class FST>
55 template <layout_type L1, layout_type L2,
class T>
58 using type = std::conditional_t<L1 == L2 && L1 != layout_type::dynamic, xcontiguous_iterable<T>,
xiterable<T>>;
61 template <layout_type L1, layout_type L2,
class T>
62 using select_iterable_base_t =
typename select_iterable_base<L1, L2, T>::type;
65 template <
class CT,
class S, layout_type L,
class FST>
68 template <
class CT,
class S, layout_type L,
class FST>
71 using xexpression_type = std::decay_t<CT>;
72 using undecay_expression = CT;
73 using reference = inner_reference_t<undecay_expression>;
74 using const_reference =
typename xexpression_type::const_reference;
75 using size_type =
typename xexpression_type::size_type;
76 using shape_type = std::decay_t<S>;
77 using undecay_shape = S;
78 using storage_getter = FST;
79 using inner_storage_type =
typename storage_getter::type;
80 using temporary_type =
typename detail::xtype_for_shape<
81 S>::template type<typename xexpression_type::value_type, xexpression_type::static_layout>;
82 using storage_type = std::remove_reference_t<inner_storage_type>;
86 template <
class CT,
class S, layout_type L,
class FST>
89 using inner_shape_type = std::decay_t<S>;
90 using inner_strides_type = get_strides_t<inner_shape_type>;
91 using inner_backstrides_type_type = inner_strides_type;
93 using const_stepper = std::conditional_t<
98 using stepper = std::conditional_t<
104 template <
class CT,
class S, layout_type L,
class FST,
class RHS>
127 template <
class CT,
class S, layout_type L = layout_type::dynamic,
class FST = detail::flat_storage_getter<CT, XTENSOR_DEFAULT_TRAVERSAL>>
129 :
public xview_semantic<xstrided_view<CT, S, L, FST>>,
130 public select_iterable_base_t<L, std::decay_t<CT>::static_layout, xstrided_view<CT, S, L, FST>>,
132 public extension::xstrided_view_base_t<CT, S, L, FST>
138 using semantic_base = xview_semantic<self_type>;
139 using extension_base = extension::xstrided_view_base_t<CT, S, L, FST>;
140 using expression_tag =
typename extension_base::expression_tag;
142 using xexpression_type =
typename base_type::xexpression_type;
143 using base_type::is_const;
145 using value_type =
typename base_type::value_type;
146 using reference =
typename base_type::reference;
147 using const_reference =
typename base_type::const_reference;
148 using pointer =
typename base_type::pointer;
149 using const_pointer =
typename base_type::const_pointer;
150 using size_type =
typename base_type::size_type;
151 using difference_type =
typename base_type::difference_type;
153 using inner_storage_type =
typename base_type::inner_storage_type;
154 using storage_type =
typename base_type::storage_type;
155 using linear_iterator =
typename storage_type::iterator;
156 using const_linear_iterator =
typename storage_type::const_iterator;
157 using reverse_linear_iterator = std::reverse_iterator<linear_iterator>;
158 using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>;
160 using iterable_base = select_iterable_base_t<L, xexpression_type::static_layout, self_type>;
161 using inner_shape_type =
typename base_type::inner_shape_type;
162 using inner_strides_type =
typename base_type::inner_strides_type;
163 using inner_backstrides_type =
typename base_type::inner_backstrides_type;
164 using shape_type =
typename base_type::shape_type;
165 using strides_type =
typename base_type::strides_type;
166 using backstrides_type =
typename base_type::backstrides_type;
168 using stepper =
typename iterable_base::stepper;
169 using const_stepper =
typename iterable_base::const_stepper;
171 using base_type::contiguous_layout;
172 using base_type::static_layout;
175 using base_index_type = xindex_type_t<shape_type>;
177 using data_alignment = xt_simd::container_alignment_t<storage_type>;
178 using simd_type = xt_simd::simd_type<value_type>;
179 using simd_value_type = xt_simd::simd_type<value_type>;
180 using bool_load_type =
typename base_type::bool_load_type;
187 && std::is_lvalue_reference_v<
188 decltype(std::declval<const storage_type&>()[0])>;
190 template <
class CTA,
class SA>
194 strides_type&& view_strides,
201 self_type& operator=(
const self_type&);
207 disable_xexpression<E, self_type>& operator=(
const E& e);
211 using base_type::is_contiguous;
217 using base_type::operator();
220 using base_type::operator[];
233 linear_iterator linear_begin();
234 linear_iterator linear_end();
235 const_linear_iterator linear_begin()
const;
236 const_linear_iterator linear_end()
const;
237 const_linear_iterator linear_cbegin()
const;
238 const_linear_iterator linear_cend()
const;
240 reverse_linear_iterator linear_rbegin();
241 reverse_linear_iterator linear_rend();
242 const_reverse_linear_iterator linear_rbegin()
const;
243 const_reverse_linear_iterator linear_rend()
const;
244 const_reverse_linear_iterator linear_crbegin()
const;
245 const_reverse_linear_iterator linear_crend()
const;
247 template <
class ST,
class STEP = stepper>
248 disable_indexed_stepper_t<STEP> stepper_begin(
const ST& iteration_shape);
249 template <
class ST,
class STEP = stepper>
250 disable_indexed_stepper_t<STEP> stepper_end(
const ST& iteration_shape,
layout_type l);
252 template <
class ST,
class STEP = stepper>
253 enable_indexed_stepper_t<STEP> stepper_begin(
const ST& iteration_shape);
254 template <
class ST,
class STEP = stepper>
255 enable_indexed_stepper_t<STEP> stepper_end(
const ST& iteration_shape,
layout_type l);
257 template <
class ST,
class STEP = const_stepper>
258 disable_indexed_stepper_t<STEP> stepper_begin(
const ST& iteration_shape)
const;
259 template <
class ST,
class STEP = const_stepper>
260 disable_indexed_stepper_t<STEP> stepper_end(
const ST& iteration_shape,
layout_type l)
const;
262 template <
class ST,
class STEP = const_stepper>
263 enable_indexed_stepper_t<STEP> stepper_begin(
const ST& iteration_shape)
const;
264 template <
class ST,
class STEP = const_stepper>
265 enable_indexed_stepper_t<STEP> stepper_end(
const ST& iteration_shape,
layout_type l)
const;
267 template <
class requested_type>
268 using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
270 template <
class align,
class simd>
271 void store_simd(size_type i,
const simd& e)
272 requires provides_simd_interface;
274 template <class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
275 simd_return_type<requested_type> load_simd(size_type i)
const
276 requires provides_simd_interface;
278 reference data_element(size_type i);
279 const_reference data_element(size_type i)
const;
281 reference flat(size_type i);
282 const_reference flat(size_type i)
const;
284 using container_iterator = std::
285 conditional_t<is_const, typename storage_type::const_iterator, typename storage_type::iterator>;
286 using const_container_iterator =
typename storage_type::const_iterator;
292 rebind_t<E> build_view(E&& e)
const;
296 container_iterator data_xbegin() noexcept;
297 const_container_iterator data_xbegin() const noexcept;
298 container_iterator data_xend(
layout_type l, size_type offset) noexcept;
299 const_container_iterator data_xend(
layout_type l, size_type offset) const noexcept;
302 It data_xbegin_impl(It begin) const noexcept;
305 It data_xend_impl(It end,
layout_type l, size_type offset) const noexcept;
307 void assign_temporary_impl(temporary_type&& tmp);
309 using base_type::set_offset;
312 friend class xstepper;
313 friend class xview_semantic<self_type>;
317 friend class xaxis_iterator;
319 friend class xaxis_slice_iterator;
327 using xstrided_slice = std::variant<
339 xrange_adaptor<placeholders::xtuph, placeholders::xtuph, placeholders::xtuph>,
377 template <class CT, class S,
layout_type L, class FST>
378 template <class CTA, class SA>
382 strides_type&& view_strides,
386 : base_type(std::forward<CTA>(e), std::forward<SA>(view_shape), std::move(view_strides), offset, view_layout)
392 template <
class CT,
class S, layout_type L,
class FST>
393 inline auto xstrided_view<CT, S, L, FST>::operator=(
const self_type& rhs) -> self_type&
406 template <
class CT,
class S, layout_type L,
class FST>
408 inline auto xstrided_view<CT, S, L, FST>::operator=(
const xexpression<E>& e) -> self_type&
410 return semantic_base::operator=(e);
415 template <
class CT,
class S, layout_type L,
class FST>
417 inline auto xstrided_view<CT, S, L, FST>::operator=(
const E& e) -> disable_xexpression<E, self_type>&
423 template <
class CT,
class S, layout_type L,
class FST>
424 inline void xstrided_view<CT, S, L, FST>::assign_temporary_impl(temporary_type&& tmp)
427 fast_assign = xassign_traits<xstrided_view<CT, S, L, FST>, temporary_type>::simd_strided_assign();
428 if constexpr (fast_assign)
430 using self_type = xstrided_view<CT, S, L, FST>;
431 parallel_assigner_t<self_type, temporary_type, default_parallel_tag> assigner;
432 assigner.strided_loop_assign(*
this, tmp);
436 std::copy(tmp.cbegin(), tmp.cend(), this->begin());
449 template <
class CT,
class S, layout_type L,
class FST>
455 std::fill(this->linear_begin(), this->linear_end(), value);
459 std::fill(this->begin(), this->end(), value);
465 template <
class CT,
class S, layout_type L,
class FST>
466 inline auto xstrided_view<CT, S, L, FST>::data_element(size_type i) -> reference
471 template <
class CT,
class S, layout_type L,
class FST>
472 inline auto xstrided_view<CT, S, L, FST>::data_element(size_type i)
const -> const_reference
477 template <
class CT,
class S, layout_type L,
class FST>
483 template <
class CT,
class S, layout_type L,
class FST>
489 template <
class CT,
class S, layout_type L,
class FST>
495 template <
class CT,
class S, layout_type L,
class FST>
501 template <
class CT,
class S, layout_type L,
class FST>
504 return this->linear_cbegin();
507 template <
class CT,
class S, layout_type L,
class FST>
510 return this->linear_cend();
513 template <
class CT,
class S, layout_type L,
class FST>
519 template <
class CT,
class S, layout_type L,
class FST>
525 template <
class CT,
class S, layout_type L,
class FST>
528 return reverse_linear_iterator(this->linear_begin());
531 template <
class CT,
class S, layout_type L,
class FST>
534 return reverse_linear_iterator(this->linear_end());
537 template <
class CT,
class S, layout_type L,
class FST>
540 return this->linear_crbegin();
543 template <
class CT,
class S, layout_type L,
class FST>
546 return this->linear_crend();
549 template <
class CT,
class S, layout_type L,
class FST>
552 return const_reverse_linear_iterator(this->linear_cbegin());
555 template <
class CT,
class S, layout_type L,
class FST>
558 return const_reverse_linear_iterator(this->linear_cend());
565 template <
class CT,
class S, layout_type L,
class FST>
566 template <
class ST,
class STEP>
568 -> disable_indexed_stepper_t<STEP>
570 size_type offset = iteration_shape.size() -
dimension();
571 return stepper(
this, data_xbegin(), offset);
574 template <
class CT,
class S, layout_type L,
class FST>
575 template <
class ST,
class STEP>
577 -> disable_indexed_stepper_t<STEP>
579 size_type offset = iteration_shape.size() -
dimension();
580 return stepper(
this, data_xend(l, offset), offset);
583 template <
class CT,
class S, layout_type L,
class FST>
584 template <
class ST,
class STEP>
586 -> enable_indexed_stepper_t<STEP>
588 size_type offset = iteration_shape.size() -
dimension();
589 return stepper(
this, offset);
592 template <
class CT,
class S, layout_type L,
class FST>
593 template <
class ST,
class STEP>
595 -> enable_indexed_stepper_t<STEP>
597 size_type offset = iteration_shape.size() -
dimension();
598 return stepper(
this, offset,
true);
601 template <
class CT,
class S, layout_type L,
class FST>
602 template <
class ST,
class STEP>
604 -> disable_indexed_stepper_t<STEP>
606 size_type offset = iteration_shape.size() -
dimension();
607 return const_stepper(
this, data_xbegin(), offset);
610 template <
class CT,
class S, layout_type L,
class FST>
611 template <
class ST,
class STEP>
613 -> disable_indexed_stepper_t<STEP>
615 size_type offset = iteration_shape.size() -
dimension();
616 return const_stepper(
this, data_xend(l, offset), offset);
619 template <
class CT,
class S, layout_type L,
class FST>
620 template <
class ST,
class STEP>
622 -> enable_indexed_stepper_t<STEP>
624 size_type offset = iteration_shape.size() -
dimension();
625 return const_stepper(
this, offset);
628 template <
class CT,
class S, layout_type L,
class FST>
629 template <
class ST,
class STEP>
631 -> enable_indexed_stepper_t<STEP>
633 size_type offset = iteration_shape.size() -
dimension();
634 return const_stepper(
this, offset,
true);
637 template <
class CT,
class S, layout_type L,
class FST>
641 return begin +
static_cast<std::ptrdiff_t
>(this->
data_offset());
644 template <
class CT,
class S, layout_type L,
class FST>
649 return strided_data_end(*
this, begin + std::ptrdiff_t(this->
data_offset()), l, offset);
652 template <
class CT,
class S, layout_type L,
class FST>
655 return data_xbegin_impl(this->
storage().begin());
658 template <
class CT,
class S, layout_type L,
class FST>
661 return data_xbegin_impl(this->
storage().cbegin());
664 template <
class CT,
class S, layout_type L,
class FST>
666 -> container_iterator
668 return data_xend_impl(this->
storage().begin(), l, offset);
671 template <
class CT,
class S, layout_type L,
class FST>
673 -> const_container_iterator
675 return data_xend_impl(this->
storage().cbegin(), l, offset);
678 template <
class CT,
class S, layout_type L,
class FST>
679 template <
class alignment,
class simd>
681 requires provides_simd_interface
683 using align_mode = driven_align_mode_t<alignment, data_alignment>;
684 xt_simd::store_as(&(
storage()[i]), e, align_mode());
687 template <
class CT,
class S, layout_type L,
class FST>
688 template <
class alignment,
class requested_type, std::
size_t N>
690 requires provides_simd_interface
692 using align_mode = driven_align_mode_t<alignment, data_alignment>;
693 return xt_simd::load_as<requested_type>(&(
storage()[i]), align_mode());
696 template <
class CT,
class S, layout_type L,
class FST>
700 inner_shape_type sh(this->
shape());
701 inner_strides_type str(this->
strides());
731 template <layout_type L,
class E,
class S,
class X>
735 return view_type(std::forward<E>(e), std::forward<S>(shape), std::forward<X>(
strides), offset,
layout);
740 struct no_adj_strides_policy
744 inline void resize(std::size_t)
748 inline void set_fake_slice(std::size_t)
752 template <
class ST,
class S>
754 const xstrided_slice_vector& ,
796 detail::strided_view_args<detail::no_adj_strides_policy> args;
799 detail::get_strides<XTENSOR_DEFAULT_TRAVERSAL>(e),
800 detail::get_offset<XTENSOR_DEFAULT_TRAVERSAL>(e),
807 std::move(args.new_shape),
808 std::move(args.new_strides),
816 template <
typename S>
819 template <std::size_t... X>
820 struct rebind_shape<
xt::fixed_shape<X...>>
828 using type = rebind_container_t<size_t, S>;
832 inline void recalculate_shape_impl(S& shape,
size_t size)
834 if constexpr (std::is_signed_v<get_value_type_t<typename std::decay<S>::type>>)
836 using value_type = get_value_type_t<typename std::decay_t<S>>;
837 XTENSOR_ASSERT(std::count(shape.cbegin(), shape.cend(), -1) <= 1);
838 auto iter = std::find(shape.begin(), shape.end(), -1);
839 if (iter != std::end(shape))
841 const auto total = std::accumulate(shape.cbegin(), shape.cend(), -1, std::multiplies<int>{});
842 const auto missing_dimension = size /
static_cast<size_t>(total);
843 (*iter) =
static_cast<value_type
>(missing_dimension);
849 inline auto recalculate_shape(S&& shape,
size_t size)
851 return recalculate_shape_impl(shape, size);
855 template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL,
class E,
class S>
856 inline auto reshape_view(E&& e, S&&
shape)
860 "traversal has to be row or column major"
863 using shape_type = std::decay_t<
decltype(
shape)>;
864 using unsigned_shape_type =
typename detail::rebind_shape<shape_type>::type;
865 get_strides_t<unsigned_shape_type>
strides;
867 detail::recalculate_shape(
shape, e.size());
870 constexpr auto computed_layout = std::decay_t<E>::static_layout == L ? L :
layout_type::dynamic;
875 detail::flat_adaptor_getter<xclosure_t<E>, L>>;
878 xtl::forward_sequence<unsigned_shape_type, S>(
shape),
898 template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL,
class E,
class S>
901 return reshape_view<L>(std::forward<E>(e), std::forward<S>(shape));
904 template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL,
class E,
class I, std::
size_t N>
907 using shape_type = std::array<std::size_t, N>;
908 return reshape_view<L>(std::forward<E>(e), xtl::forward_sequence<shape_type,
decltype(
shape)>(
shape), order);
911 template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL,
class E,
class I, std::
size_t N>
912 inline auto reshape_view(E&& e,
const I (&
shape)[N])
914 using shape_type = std::array<I, N>;
915 return reshape_view<L>(std::forward<E>(e), xtl::forward_sequence<shape_type,
decltype(
shape)>(
shape));
Fixed shape implementation for compile time defined arrays.
Base class for implementation of common expression access methods.
Base class for implementation of common expression constant access methods.
size_type size() const noexcept(noexcept(derived_cast().shape()))
size_type dimension() const noexcept
const_reference at(Args... args) const
Base class for xexpressions.
Base class for multidimensional iterable expressions.
layout_type layout() const noexcept
reference unchecked(Args... args)
xstrided_view_base(CTA &&e, SA &&shape, strides_type &&strides, size_type offset, layout_type layout) noexcept
Constructs an xstrided_view_base.
bool has_linear_assign(const O &strides) const noexcept
const inner_strides_type & strides() const noexcept
bool broadcast_shape(O &shape, bool reuse_cache=false) const
const inner_backstrides_type & backstrides() const noexcept
const inner_shape_type & shape() const noexcept
size_type data_offset() const noexcept
storage_type & storage() noexcept
xexpression_type & expression() noexcept
reference element(It first, It last)
View of an xexpression using strides.
xstrided_view(CTA &&e, SA &&view_shape, strides_type &&view_strides, std::size_t offset, layout_type view_layout) noexcept
Constructs an xstrided_view.
void fill(const T &value)
Fills the view with the given value.
storage_type & storage() noexcept
Returns a reference to the buffer containing the elements of the view.
size_type data_offset() const noexcept
Returns the offset to the first element in the view.
const inner_shape_type & shape() const noexcept
Returns the shape of the xtrided_view_base.
self_type & operator=(const xexpression< E > &e)
The extended assignment operator.
layout_type layout() const noexcept
Returns the layout of the xtrided_view_base.
const inner_strides_type & strides() const noexcept
Returns the strides of the xtrided_view_base.
derived_type & assign_temporary(temporary_type &&)
Assigns the temporary tmp to *this.
std::size_t compute_strides(const shape_type &shape, layout_type l, strides_type &strides)
Compute the strides given the shape and the layout of an array.
auto strides(const E &e, stride_type type=stride_type::normal) noexcept
Get strides of an object.
standard mathematical functions for xexpressions
std::vector< xstrided_slice< std::ptrdiff_t > > xstrided_slice_vector
vector of slices used to build a xstrided_view
auto strided_view(E &&e, S &&shape, X &&stride, std::size_t offset=0, layout_type layout=L) noexcept
Construct a strided view from an xexpression, shape, strides and offset.