remove difference between strides and slices.

Author: bassoy

include/boost/numeric/ublas/tensor/span.hpp

@@ -21,13 +21,6 @@
 
 #include "concepts.hpp"
 
-namespace boost::numeric::ublas::tag{
-
-struct sliced  {};
-struct strided {};
-
-} // namespace boost::numeric::ublas::tag
-
 
 namespace boost::numeric::ublas {
 
@@ -43,21 +36,17 @@ namespace boost::numeric::ublas {
 	*/
 
 
+//template<class unsigned_type>
+//class span;
 
-//using offsets = std::vector<std::ptrdiff_t>;
-
-template<class span_tag, class unsigned_type>
-class span;
-
-
-static constexpr inline std::size_t max = std::numeric_limits<std::size_t>::max();
-
-template<>
-class span<tag::strided, std::size_t>
+template<integral unsigned_type>
+class span
 {
 public:
-	using span_tag = tag::strided;
-	using value_type = std::size_t;
+    using value_type = unsigned_type;
+
+    static constexpr inline value_type max = std::numeric_limits<value_type>::max();
+
 
 	// covers the complete range of one dimension
 	// e.g. a(:)
@@ -92,6 +81,13 @@ class span<tag::strided, std::size_t>
 		}
 	}
 
+    // covers a linear range of one dimension
+    // e.g. a(1:n)
+    span(value_type f, value_type l)
+        : span(f,1,l)
+    {
+    }
+
 	// covers only one index of one dimension
 	// e.g. a(1) or a(end)
 	span(value_type n)
@@ -142,105 +138,34 @@ class span<tag::strided, std::size_t>
 	value_type first_, last_ , step_, size_;
 };
 
-using strided_span = span<tag::strided, std::size_t>;
-
-} // namespace
-
-
-/////////////
-
-namespace boost::numeric::ublas {
-
-template<>
-class span<tag::sliced, std::size_t> :
-		private span<tag::strided, std::size_t>
-{
-	using super_type = span<tag::strided,std::size_t>;
-public:
-	using span_tag = tag::sliced;
-	using value_type = typename super_type::value_type;
-	constexpr explicit span()
-		: super_type()
-	{
-	}
-
-	span(value_type f, value_type l)
-		: super_type(f, value_type(1), l )
-	{
-	}
-
-	span(value_type n)
-		: super_type(n)
-	{
-	}
-
-	span(span const& other)
-		: super_type(other)
-	{
-	}
-
-  inline span& operator=(const span &other)
-	{
-		super_type::operator=(other);
-		return *this;
-	}
-
-	~span() = default;
-
-  inline value_type operator[] (std::size_t idx) const
-	{
-		return super_type::operator [](idx);
-	}
-
-  inline auto first() const {return super_type::first(); }
-  inline auto last () const {return super_type::last (); }
-  inline auto step () const {return super_type::step (); }
-  inline auto size () const {return super_type::size (); }
-
-  inline span operator()(const span &rhs) const
-	{
-		auto const& lhs = *this;
-		return span( rhs.first_ + lhs.first_, rhs.last_  + lhs.first_ );
-	}
-};
-
-using sliced_span = span<tag::sliced, std::size_t>;
-
-
-template<integral unsigned_type_left, integral unsigned_type_right>
-inline auto ran(unsigned_type_left f, unsigned_type_right l)
-{
-	return sliced_span(f,l);
-}
-
-template<integral unsigned_type_left, integral unsigned_type_middle, integral unsigned_type_right>
-inline auto ran(unsigned_type_left f, unsigned_type_middle s, unsigned_type_right l)
-{
-	return strided_span(f,s,l);
-}
+using sspan = span<std::size_t>;
 
 } // namespace
 
 
-template <class span_tag, class unsigned_type>
-std::ostream& operator<< (std::ostream& out,  boost::numeric::ublas::span<span_tag,unsigned_type> const& s)
+template <boost::numeric::ublas::integral unsigned_type>
+std::ostream& operator<< (std::ostream& out,  boost::numeric::ublas::span<unsigned_type> const& s)
 {
   return out << "[" << s.first() << ":" << s.step() << ":" << s.last() << "]" << std::endl;
 }
 
-template<class span_tag_lhs, class span_tag_rhs, class unsigned_type>
+template<
+        boost::numeric::ublas::integral unsigned_type_lhs,
+        boost::numeric::ublas::integral unsigned_type_rhs>
 inline bool operator==(
-		boost::numeric::ublas::span<span_tag_lhs,unsigned_type> const& lhs,
-		boost::numeric::ublas::span<span_tag_rhs,unsigned_type> const& rhs)
+        boost::numeric::ublas::span<unsigned_type_lhs> const& lhs,
+        boost::numeric::ublas::span<unsigned_type_rhs> const& rhs)
 {
 	return lhs.first() == rhs.first() && lhs.last() == rhs.last() && lhs.step() == rhs.step();
 }
 
 
-template<class span_tag_lhs, class span_tag_rhs, class unsigned_type>
+template<
+        boost::numeric::ublas::integral unsigned_type_lhs,
+        boost::numeric::ublas::integral unsigned_type_rhs>
 inline bool operator!=(
-		boost::numeric::ublas::span<span_tag_lhs,unsigned_type> const& lhs,
-		boost::numeric::ublas::span<span_tag_rhs,unsigned_type> const& rhs)
+        boost::numeric::ublas::span<unsigned_type_lhs> const& lhs,
+        boost::numeric::ublas::span<unsigned_type_rhs> const& rhs)
 {
 	return lhs.first() != rhs.first() || lhs.last() != rhs.last() || lhs.step() != rhs.step();
 }

include/boost/numeric/ublas/tensor/subtensor.hpp

@@ -29,11 +29,9 @@ namespace boost::numeric::ublas {
 
 /** @brief A view of a dense tensor of values of type \c T.
 	*
-	* @tparam T type of the objects stored in the tensor (like int, double, complex,...)
-	* @tparam F
-	* @tparam A The type of the storage array of the tensor. Default is \c unbounded_array<T>. \c <bounded_array<T> and \c std::vector<T> can also be used
+    * @tparam T tensor type
 */
-template<class S, class T>
+template<class T>
 class subtensor;
 
 
@@ -48,22 +46,20 @@ class subtensor;
 		* @tparam A The type of the storage array of the tensor. Default is \c unbounded_array<T>. \c <bounded_array<T> and \c std::vector<T> can also be used
 		*/
 template<class T, class F>
-class subtensor <tag::sliced, tensor_dynamic<T,F>>
+class subtensor <tensor_dynamic<T,F>>
     : public detail::tensor_expression<
-        subtensor<tag::sliced,tensor_dynamic<T,F>> ,
-        subtensor<tag::sliced,tensor_dynamic<T,F>> >
+        subtensor<tensor_dynamic<T,F>> ,
+        subtensor<tensor_dynamic<T,F>> >
 {
 
   static_assert( std::is_same<F,layout::first_order>::value || std::is_same<F,layout::last_order >::value,
                 "boost::numeric::tensor template class only supports first- or last-order storage formats.");
 
   using tensor_type = tensor_dynamic<T,F>;
-  using self_type  = subtensor<tag::sliced, tensor_type>;
+  using self_type  = subtensor<tensor_type>;
 public:
 
-  using domain_tag = tag::sliced;
-
-  using span_type = span<domain_tag,std::size_t>;
+  using span_type = sspan;
 
   template<class derived_type>
   using tensor_expression_type = detail::tensor_expression<self_type,derived_type>;
@@ -116,23 +112,23 @@ class subtensor <tag::sliced, tensor_dynamic<T,F>>
 	 */
 	BOOST_UBLAS_INLINE
 	subtensor (tensor_type& t)
-		: super_type    ()
-		, spans_        ()
-		, extents_      (t.extents())
-		, strides_      (t.strides())
-		, span_strides_ (t.strides())
-		, data_         (t.data())
+        : super_type    ()
+        , spans_        ()
+        , extents_      (t.extents())
+        , strides_      (t.strides())
+        , span_strides_ (t.strides())
+        , data_         (t.data())
 	{
 	}
 
 	template<typename ... span_types>
-	subtensor(tensor_type& t, span_types&& ... spans)
-			: super_type     ()
-      , spans_         (detail::generate_span_vector<span_type>(t.extents(),std::forward<span_types>(spans)...))
-      , extents_       (detail::to_extents(spans_))
-    , strides_         (ublas::to_strides(extents_,layout_type{}))
-      , span_strides_  (detail::to_span_strides(t.strides(),spans_))
-      , data_          {t.data() + detail::to_offset(t.strides(), spans_)}
+    subtensor(tensor_type& t, span_types&& ... spans)
+        : super_type     ()
+        , spans_         (detail::generate_vector<span_type>(t.extents(),std::forward<span_types>(spans)...))
+        , extents_       (detail::to_extents(spans_))
+        , strides_       (ublas::to_strides(extents_,layout_type{}))
+        , span_strides_  (detail::to_span_strides(t.strides(),spans_))
+        , data_          {t.data() + detail::to_offset(t.strides(), spans_)}
 	{
 //		if( m == nullptr)
 //			throw std::length_error("Error in tensor_view<T>::tensor_view : multi_array_type is nullptr.");
@@ -145,16 +141,16 @@ class subtensor <tag::sliced, tensor_dynamic<T,F>>
 	 *
    * @note is similar to a handle to a tensor
 	 */
-  explicit
-  subtensor (tensor_type const& t)
-    : super_type    ()
-    , spans_        ()
-    , extents_      (t.extents())
-    , strides_      (t.strides())
-    , span_strides_ (t.strides())
-    , data_         (t.data())
-  {
-  }
+    explicit
+    subtensor (tensor_type const& t)
+        : super_type    ()
+        , spans_        ()
+        , extents_      (t.extents())
+        , strides_      (t.strides())
+        , span_strides_ (t.strides())
+        , data_         (t.data())
+    {
+    }