123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364 |
- //
- // 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_
|