boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/ublas/tensor/multi_index.hpp

@@ -0,0 +1,110 @@
+//
+//  Copyright (c) 2018-2019, Cem Bassoy, cem.bassoy@gmail.com
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  Fraunhofer IOSB, Ettlingen, Germany
+//
+
+#ifndef BOOST_UBLAS_TENSOR_MULTI_INDEX_HPP
+#define BOOST_UBLAS_TENSOR_MULTI_INDEX_HPP
+
+
+#include <cstddef>
+#include <array>
+#include <vector>
+
+#include "multi_index_utility.hpp"
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+namespace index {
+
+template<std::size_t I>
+struct index_type;
+
+} // namespace indices
+}
+}
+}
+
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+
+/** @brief Proxy class for the einstein summation notation
+ *
+ * Denotes an array of index_type types ::_a for 0<=K<=16 is used in tensor::operator()
+*/
+template<std::size_t N>
+class multi_index
+{
+public:
+	multi_index() = delete;
+
+	template<std::size_t I, class ... indexes>
+	constexpr multi_index(index::index_type<I> const& i, indexes ... is )
+	  : _base{i(), is()... }
+	{
+		static_assert( sizeof...(is)+1 == N,
+		               "Static assert in boost::numeric::ublas::multi_index: number of constructor arguments is not equal to the template parameter." );
+
+		static_assert( valid_multi_index<std::tuple<index::index_type<I>, indexes ...> >::value,
+		               "Static assert in boost::numeric::ublas::multi_index: indexes occur twice in multi-index." );
+	}
+
+	multi_index(multi_index const& other)
+	  : _base(other._base)
+	{
+	}
+
+	multi_index& operator=(multi_index const& other)
+	{
+		this->_base = other._base;
+		return *this;
+	}
+
+	~multi_index() = default;
+
+	auto const& base() const { return _base; }
+	constexpr auto size() const { return _base.size(); }
+	constexpr auto at(std::size_t i) const { return _base.at(i); }
+	constexpr auto operator[](std::size_t i) const { return _base.at(i); }
+
+private:
+	std::array<std::size_t, N> _base;
+};
+
+template<std::size_t K, std::size_t N>
+constexpr auto get(multi_index<N> const& m) { return std::get<K>(m.base()); }
+
+template<std::size_t M, std::size_t N>
+auto array_to_vector(multi_index<M> const& lhs, multi_index<N> const& rhs)
+{
+	using vtype = std::vector<std::size_t>;
+
+	auto pair_of_vector = std::make_pair( vtype {}, vtype{}  );
+
+	for(auto i = 0u; i < N; ++i)
+		for(auto j = 0u; j < M; ++j)
+			if ( lhs.at(i) == rhs.at(j) && lhs.at(i) != boost::numeric::ublas::index::_())
+				pair_of_vector.first .push_back( i+1 ),
+				    pair_of_vector.second.push_back( j+1 );
+
+	return pair_of_vector;
+}
+
+
+
+
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+#endif // MULTI_INDEX_HPP

package/boost/numeric/ublas/tensor/multi_index_utility.hpp

@@ -0,0 +1,364 @@
+//
+//  Copyright (c) 2018-2019, Cem Bassoy, cem.bassoy@gmail.com
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  Fraunhofer IOSB, Ettlingen, Germany
+//
+
+#ifndef BOOST_UBLAS_TENSOR_MULTI_INDEX_UTILITY_HPP
+#define BOOST_UBLAS_TENSOR_MULTI_INDEX_UTILITY_HPP
+
+
+#include <tuple>
+#include <type_traits>
+
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+
+template<class ... index_types>
+struct has_index_impl;
+
+template<class itype_left, class itype_right>
+struct has_index_impl<itype_left, itype_right>
+{
+	static constexpr bool value = itype_left::value == itype_right::value;
+};
+
+template<class itype_left>
+struct has_index_impl <itype_left, std::tuple<> >
+{
+	static constexpr bool value = false;
+};
+
+template<class itype_left, class itype_right>
+struct has_index_impl <itype_left, std::tuple<itype_right> >
+{
+	static constexpr bool value = has_index_impl<itype_left,itype_right>::value;
+};
+
+template<class itype_left, class itype_right, class ... index_types>
+struct has_index_impl <itype_left, std::tuple<itype_right, index_types...> >
+{
+	using next_type = has_index_impl<itype_left, std::tuple<index_types...>>;
+	static constexpr bool value = has_index_impl<itype_left,itype_right>::value || next_type::value;
+};
+} // namespace detail
+
+
+
+/** @brief has_index is true if index occurs once or more in a multi-index
+ *
+ * @note a multi-index represents as tuple of single indexes of type boost::numeric::ublas::index::index_type
+ *
+ * @code auto has_index_value = has_index<index_type<1>, std::tuple<index_type<2>,index_type<1>> >::value; @endcode
+ *
+ * @tparam index_type type of index
+ * @tparam tuple_type type of std::tuple representing a multi-index
+*/
+template<class index_type, class tuple_type>
+struct has_index
+{
+	static constexpr bool value = detail::has_index_impl<std::decay_t<index_type>,std::decay_t<tuple_type>>::value;
+};
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+
+template<class ... index_types>
+struct valid_multi_index_impl;
+
+template<>
+struct valid_multi_index_impl<std::tuple<>>
+{
+	static constexpr bool value = true;
+};
+
+template<class itype>
+struct valid_multi_index_impl<std::tuple<itype>>
+{
+	static constexpr bool value = true;
+};
+
+
+template<class itype, class ... index_types>
+struct valid_multi_index_impl<std::tuple<itype,index_types...>>
+{
+	using ttype     = std::tuple<index_types...>;
+	using has_index_type = has_index<itype, ttype>;
+
+	static constexpr bool is_index_zero   = itype::value==0ul;
+	static constexpr bool has_index_value = has_index_type::value && !is_index_zero;
+	static constexpr bool value = !has_index_value && valid_multi_index_impl<ttype>::value;
+};
+} // namespace detail
+
+/** @brief valid_multi_index is true if indexes occur only once in a multi-index
+ *
+ * @note a multi-index represents as tuple of single indexes of type boost::numeric::ublas::index::index_type
+ *
+ * @code auto valid = valid_multi_index<  std::tuple<index_type<2>,index_type<1>>  >::value;
+ * @endcode
+ *
+ * @tparam tuple_type type of std::tuple representing a multi-index
+*/
+template<class tupe_type>
+struct valid_multi_index
+{
+	static constexpr bool value = detail::valid_multi_index_impl<std::decay_t<tupe_type>>::value;
+};
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+template<class ... index_types >
+struct number_equal_indexes_impl;
+
+template<class ... itypes_right >
+struct number_equal_indexes_impl < std::tuple<>, std::tuple<itypes_right...>>
+{
+	static constexpr unsigned value  = 0;
+};
+
+template<class itype, class ... itypes_left, class ... itypes_right>
+struct number_equal_indexes_impl < std::tuple<itype,itypes_left...>, std::tuple<itypes_right...>>
+{
+	using tuple_right = std::tuple<itypes_right...>;
+	using has_index_type = has_index<itype, tuple_right>;
+
+	static constexpr bool is_index_zero   = itype::value==0ul;
+	static constexpr bool has_index_value = has_index_type::value && !is_index_zero;
+
+	using next_type = number_equal_indexes_impl< std::tuple<itypes_left...>, tuple_right >;
+	static constexpr unsigned v = has_index_value ? 1 : 0;
+	static constexpr unsigned value  = v + next_type::value;
+};
+} // namespace detail
+
+
+/** @brief number_equal_indexes contains the number of equal indexes of two multi-indexes
+ *
+ * @note a multi-index represents as tuple of single indexes of type boost::numeric::ublas::index::index_type
+ *
+ *
+ * @code auto num = number_equal_indexes<
+ *                        std::tuple<index_type<2>,index_type<1>>,
+ *                        std::tuple<index_type<1>,index_type<3>>  >::value;
+ * @endcode
+ *
+ * @tparam tuple_type_left  type of left std::tuple representing a multi-index
+ * @tparam tuple_type_right type of right std::tuple representing a multi-index
+*/
+template<class tuple_left, class tuple_right>
+struct number_equal_indexes
+{
+	static constexpr unsigned value  =
+	    detail::number_equal_indexes_impl< std::decay_t<tuple_left>, std::decay_t<tuple_right>>::value;
+};
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+
+template<std::size_t r, std::size_t m, class itype, class ttype>
+struct index_position_impl
+{
+	static constexpr auto is_same = std::is_same< std::decay_t<itype>, std::decay_t<std::tuple_element_t<r,ttype>> >::value;
+	static constexpr auto value   = is_same ? r : index_position_impl<r+1,m,itype,ttype>::value;
+};
+
+
+
+template<std::size_t m, class itype, class ttype>
+struct index_position_impl < m, m, itype, ttype>
+{
+	static constexpr auto value = std::tuple_size<ttype>::value;
+};
+
+} // namespace detail
+
+
+
+/** @brief index_position contains the zero-based index position of an index type within a multi-index
+ *
+ * @note a multi-index represents as tuple of single indexes of type boost::numeric::ublas::index::index_type
+ *
+ * @code auto num = index_position<
+ *                       index_type<1>,
+ *                       std::tuple<index_type<2>,index_type<1>>  >::value;
+ * @endcode
+ *
+ * @returns value returns 0 and N-1 if index_type is found, N otherwise where N is tuple_size_v<tuple_type>.
+ *
+ * @tparam index_type type of index
+ * @tparam tuple_type type of std::tuple that is searched for index
+*/
+template<class index_type, class tuple_type>
+struct index_position
+{
+	static constexpr auto value  = detail::index_position_impl<0ul,std::tuple_size<tuple_type>::value,std::decay_t<index_type>,std::decay_t<tuple_type>>::value;
+};
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+template<std::size_t r, std::size_t m>
+struct index_position_pairs_impl
+{
+	template<class array_type, class tuple_left, class tuple_right>
+	static constexpr void run(array_type& out, tuple_left const& lhs, tuple_right const& rhs, std::size_t p)
+	{
+		using index_type     = std::tuple_element_t<r-1,tuple_left>;
+		using has_index_type = has_index<index_type, tuple_right>;
+		using get_index_type = index_position<index_type,tuple_right>;
+		using next_type      = index_position_pairs_impl<r+1,m>;
+		if constexpr ( has_index_type::value && index_type::value != 0)
+		    out[p++] = std::make_pair(r-1,get_index_type::value);
+		next_type::run( out, lhs, rhs, p );
+	}
+};
+
+template<std::size_t m>
+struct index_position_pairs_impl<m,m>
+{
+	template<class array_type, class tuple_left, class tuple_right>
+	static constexpr void run(array_type& out, tuple_left const& , tuple_right const& , std::size_t p)
+	{
+		using index_type     = std::tuple_element_t<m-1,tuple_left>;
+		using has_index_type = has_index<index_type, tuple_right>;
+		using get_index_type = index_position<index_type, tuple_right>;
+		if constexpr ( has_index_type::value && index_type::value != 0 )
+		    out[p] = std::make_pair(m-1,get_index_type::value);
+	}
+};
+
+template<std::size_t r>
+struct index_position_pairs_impl<r,0>
+{
+	template<class array_type, class tuple_left, class tuple_right>
+	static constexpr void run(array_type&, tuple_left const& , tuple_right const& , std::size_t)
+	{}
+};
+
+
+} // namespace detail
+
+
+/** @brief index_position_pairs returns zero-based index positions of matching indexes of two multi-indexes
+ *
+ * @note a multi-index represents as tuple of single indexes of type boost::numeric::ublas::index::index_type
+ *
+ * @code auto pairs = index_position_pairs(std::make_tuple(_a,_b), std::make_tuple(_b,_c));
+ * @endcode
+ *
+ * @returns a std::array instance containing index position pairs of type std::pair<std::size_t, std::size_t>.
+ *
+ * @param lhs left std::tuple instance representing a multi-index
+ * @param rhs right std::tuple instance representing a multi-index
+*/
+template<class tuple_left, class tuple_right>
+auto index_position_pairs(tuple_left const& lhs, tuple_right const& rhs)
+{
+	using pair_type = std::pair<std::size_t,std::size_t>;
+	constexpr auto m = std::tuple_size<tuple_left >::value;
+	constexpr auto p = number_equal_indexes<tuple_left, tuple_right>::value;
+	auto array = std::array<pair_type,p>{};
+	detail::index_position_pairs_impl<1,m>::run(array, lhs, rhs,0);
+	return array;
+}
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+////////////////////////////
+////////////////////////////
+////////////////////////////
+////////////////////////////
+
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+template<class array_type, std::size_t ... R>
+constexpr auto array_to_vector_impl( array_type const& array, std::index_sequence<R...> )
+{
+	return std::make_pair(
+	      std::vector<std::size_t>{std::get<0>( std::get<R>(array) )+1 ...} ,
+	      std::vector<std::size_t>{std::get<1>( std::get<R>(array) )+1 ...} );
+}
+
+} // namespace detail
+
+
+/** @brief array_to_vector converts a std::array of zero-based index position pairs into two std::vector of one-based index positions
+ *
+ * @code auto two_vectors = array_to_vector(std::make_array ( std::make_pair(1,2), std::make_pair(3,4) ) ) ;
+ * @endcode
+ *
+ * @returns two std::vector of one-based index positions
+ *
+ * @param array std::array of zero-based index position pairs
+*/
+template<class pair_type, std::size_t N>
+constexpr auto array_to_vector( std::array<pair_type,N> const& array)
+{
+	constexpr auto sequence = std::make_index_sequence<N>{};
+	return detail::array_to_vector_impl( array, sequence );
+}
+
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+
+#endif // _BOOST_UBLAS_TENSOR_MULTI_INDEX_UTILITY_HPP_