boost.cxx 0.0.2 → 1.90.1

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

@@ -0,0 +1,288 @@
+//
+//  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_EXPRESSIONS_EVALUATION_HPP_
+#define _BOOST_UBLAS_TENSOR_EXPRESSIONS_EVALUATION_HPP_
+
+#include <type_traits>
+#include <stdexcept>
+
+
+namespace boost::numeric::ublas {
+
+template<class element_type, class storage_format, class storage_type>
+class tensor;
+
+template<class size_type>
+class basic_extents;
+
+}
+
+namespace boost::numeric::ublas::detail {
+
+template<class T, class D>
+struct tensor_expression;
+
+template<class T, class EL, class ER, class OP>
+struct binary_tensor_expression;
+
+template<class T, class E, class OP>
+struct unary_tensor_expression;
+
+}
+
+namespace boost::numeric::ublas::detail {
+
+template<class T, class E>
+struct has_tensor_types
+{ static constexpr bool value = false; };
+
+template<class T>
+struct has_tensor_types<T,T>
+{ static constexpr bool value = true; };
+
+template<class T, class D>
+struct has_tensor_types<T, tensor_expression<T,D>>
+{ static constexpr bool value = std::is_same<T,D>::value || has_tensor_types<T,D>::value; };
+
+
+template<class T, class EL, class ER, class OP>
+struct has_tensor_types<T, binary_tensor_expression<T,EL,ER,OP>>
+{ static constexpr bool value = std::is_same<T,EL>::value || std::is_same<T,ER>::value || has_tensor_types<T,EL>::value || has_tensor_types<T,ER>::value;  };
+
+template<class T, class E, class OP>
+struct has_tensor_types<T, unary_tensor_expression<T,E,OP>>
+{ static constexpr bool value = std::is_same<T,E>::value || has_tensor_types<T,E>::value; };
+
+} // namespace boost::numeric::ublas::detail
+
+
+namespace boost::numeric::ublas::detail {
+
+
+
+
+
+/** @brief Retrieves extents of the tensor
+ *
+*/
+template<class T, class F, class A>
+auto retrieve_extents(tensor<T,F,A> const& t)
+{
+	return t.extents();
+}
+
+/** @brief Retrieves extents of the tensor expression
+ *
+ * @note tensor expression must be a binary tree with at least one tensor type
+ *
+ * @returns extents of the child expression if it is a tensor or extents of one child of its child.
+*/
+template<class T, class D>
+auto retrieve_extents(tensor_expression<T,D> const& expr)
+{
+	static_assert(detail::has_tensor_types<T,tensor_expression<T,D>>::value,
+	              "Error in boost::numeric::ublas::detail::retrieve_extents: Expression to evaluate should contain tensors.");
+
+	auto const& cast_expr = static_cast<D const&>(expr);
+
+	if constexpr ( std::is_same<T,D>::value )
+	    return cast_expr.extents();
+	else
+	return retrieve_extents(cast_expr);
+}
+
+/** @brief Retrieves extents of the binary tensor expression
+ *
+ * @note tensor expression must be a binary tree with at least one tensor type
+ *
+ * @returns extents of the (left and if necessary then right) child expression if it is a tensor or extents of a child of its (left and if necessary then right) child.
+*/
+template<class T, class EL, class ER, class OP>
+auto retrieve_extents(binary_tensor_expression<T,EL,ER,OP> const& expr)
+{
+	static_assert(detail::has_tensor_types<T,binary_tensor_expression<T,EL,ER,OP>>::value,
+	              "Error in boost::numeric::ublas::detail::retrieve_extents: Expression to evaluate should contain tensors.");
+
+	if constexpr ( std::is_same<T,EL>::value )
+	    return expr.el.extents();
+
+	if constexpr ( std::is_same<T,ER>::value )
+	    return expr.er.extents();
+
+	else if constexpr ( detail::has_tensor_types<T,EL>::value )
+	    return retrieve_extents(expr.el);
+
+	else if constexpr ( detail::has_tensor_types<T,ER>::value  )
+	    return retrieve_extents(expr.er);
+}
+
+/** @brief Retrieves extents of the binary tensor expression
+ *
+ * @note tensor expression must be a binary tree with at least one tensor type
+ *
+ * @returns extents of the child expression if it is a tensor or extents of a child of its child.
+*/
+template<class T, class E, class OP>
+auto retrieve_extents(unary_tensor_expression<T,E,OP> const& expr)
+{
+
+	static_assert(detail::has_tensor_types<T,unary_tensor_expression<T,E,OP>>::value,
+	              "Error in boost::numeric::ublas::detail::retrieve_extents: Expression to evaluate should contain tensors.");
+
+	if constexpr ( std::is_same<T,E>::value )
+	    return expr.e.extents();
+
+	else if constexpr ( detail::has_tensor_types<T,E>::value  )
+	    return retrieve_extents(expr.e);
+}
+
+} // namespace boost::numeric::ublas::detail
+
+
+///////////////
+
+namespace boost::numeric::ublas::detail {
+
+template<class T, class F, class A, class S>
+auto all_extents_equal(tensor<T,F,A> const& t, basic_extents<S> const& extents)
+{
+	return extents == t.extents();
+}
+
+template<class T, class D, class S>
+auto all_extents_equal(tensor_expression<T,D> const& expr, basic_extents<S> const& extents)
+{
+	static_assert(detail::has_tensor_types<T,tensor_expression<T,D>>::value,
+	              "Error in boost::numeric::ublas::detail::all_extents_equal: Expression to evaluate should contain tensors.");
+	auto const& cast_expr = static_cast<D const&>(expr);
+
+
+	if constexpr ( std::is_same<T,D>::value )
+	    if( extents != cast_expr.extents() )
+	    return false;
+
+	if constexpr ( detail::has_tensor_types<T,D>::value )
+	    if ( !all_extents_equal(cast_expr, extents))
+	    return false;
+
+	return true;
+
+}
+
+template<class T, class EL, class ER, class OP, class S>
+auto all_extents_equal(binary_tensor_expression<T,EL,ER,OP> const& expr, basic_extents<S> const& extents)
+{
+	static_assert(detail::has_tensor_types<T,binary_tensor_expression<T,EL,ER,OP>>::value,
+	              "Error in boost::numeric::ublas::detail::all_extents_equal: Expression to evaluate should contain tensors.");
+
+	if constexpr ( std::is_same<T,EL>::value )
+	    if(extents !=  expr.el.extents())
+	    return false;
+
+	if constexpr ( std::is_same<T,ER>::value )
+	    if(extents != expr.er.extents())
+	    return false;
+
+	if constexpr ( detail::has_tensor_types<T,EL>::value )
+	    if(!all_extents_equal(expr.el, extents))
+	    return false;
+
+	if constexpr ( detail::has_tensor_types<T,ER>::value )
+	    if(!all_extents_equal(expr.er, extents))
+	    return false;
+
+	return true;
+}
+
+
+template<class T, class E, class OP, class S>
+auto all_extents_equal(unary_tensor_expression<T,E,OP> const& expr, basic_extents<S> const& extents)
+{
+
+	static_assert(detail::has_tensor_types<T,unary_tensor_expression<T,E,OP>>::value,
+	              "Error in boost::numeric::ublas::detail::all_extents_equal: Expression to evaluate should contain tensors.");
+
+	if constexpr ( std::is_same<T,E>::value )
+	    if(extents != expr.e.extents())
+	    return false;
+
+	if constexpr ( detail::has_tensor_types<T,E>::value )
+	    if(!all_extents_equal(expr.e, extents))
+	    return false;
+
+	return true;
+}
+
+} // namespace boost::numeric::ublas::detail
+
+
+namespace boost::numeric::ublas::detail {
+
+
+/** @brief Evaluates expression for a tensor
+ *
+ * Assigns the results of the expression to the tensor.
+ *
+ * \note Checks if shape of the tensor matches those of all tensors within the expression.
+*/
+template<class tensor_type, class derived_type>
+void eval(tensor_type& lhs, tensor_expression<tensor_type, derived_type> const& expr)
+{
+	if constexpr (detail::has_tensor_types<tensor_type, tensor_expression<tensor_type,derived_type> >::value )
+	    if(!detail::all_extents_equal(expr, lhs.extents() ))
+	    throw std::runtime_error("Error in boost::numeric::ublas::tensor: expression contains tensors with different shapes.");
+
+#pragma omp parallel for
+	for(auto i = 0u; i < lhs.size(); ++i)
+		lhs(i) = expr()(i);
+}
+
+/** @brief Evaluates expression for a tensor
+ *
+ * Applies a unary function to the results of the expressions before the assignment.
+ * Usually applied needed for unary operators such as A += C;
+ *
+ * \note Checks if shape of the tensor matches those of all tensors within the expression.
+*/
+template<class tensor_type, class derived_type, class unary_fn>
+void eval(tensor_type& lhs, tensor_expression<tensor_type, derived_type> const& expr, unary_fn const fn)
+{
+
+	if constexpr (detail::has_tensor_types< tensor_type, tensor_expression<tensor_type,derived_type> >::value )
+	    if(!detail::all_extents_equal( expr, lhs.extents() ))
+	    throw std::runtime_error("Error in boost::numeric::ublas::tensor: expression contains tensors with different shapes.");
+
+#pragma omp parallel for
+	for(auto i = 0u; i < lhs.size(); ++i)
+		fn(lhs(i), expr()(i));
+}
+
+
+
+/** @brief Evaluates expression for a tensor
+ *
+ * Applies a unary function to the results of the expressions before the assignment.
+ * Usually applied needed for unary operators such as A += C;
+ *
+ * \note Checks if shape of the tensor matches those of all tensors within the expression.
+*/
+template<class tensor_type, class unary_fn>
+void eval(tensor_type& lhs, unary_fn const fn)
+{
+#pragma omp parallel for
+	for(auto i = 0u; i < lhs.size(); ++i)
+		fn(lhs(i));
+}
+
+
+}
+#endif

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

@@ -0,0 +1,335 @@
+//
+//  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_NUMERIC_UBLAS_TENSOR_EXTENTS_HPP
+#define BOOST_NUMERIC_UBLAS_TENSOR_EXTENTS_HPP
+
+#include <algorithm>
+#include <initializer_list>
+#include <limits>
+#include <numeric>
+#include <stdexcept>
+#include <vector>
+
+#include <cassert>
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+
+
+/** @brief Template class for storing tensor extents with runtime variable size.
+ *
+ * Proxy template class of std::vector<int_type>.
+ *
+ */
+template<class int_type>
+class basic_extents
+{
+	static_assert( std::numeric_limits<typename std::vector<int_type>::value_type>::is_integer, "Static error in basic_layout: type must be of type integer.");
+	static_assert(!std::numeric_limits<typename std::vector<int_type>::value_type>::is_signed,  "Static error in basic_layout: type must be of type unsigned integer.");
+
+public:
+	using base_type = std::vector<int_type>;
+	using value_type = typename base_type::value_type;
+	using const_reference = typename base_type::const_reference;
+	using reference = typename base_type::reference;
+	using size_type = typename base_type::size_type;
+	using const_pointer = typename base_type::const_pointer;
+	using const_iterator = typename base_type::const_iterator;
+
+
+	/** @brief Default constructs basic_extents
+	 *
+	 * @code auto ex = basic_extents<unsigned>{};
+	 */
+	constexpr explicit basic_extents()
+	  : _base{}
+	{
+	}
+
+	/** @brief Copy constructs basic_extents from a one-dimensional container
+	 *
+	 * @code auto ex = basic_extents<unsigned>(  std::vector<unsigned>(3u,3u) );
+	 *
+	 * @note checks if size > 1 and all elements > 0
+	 *
+	 * @param b one-dimensional std::vector<int_type> container
+	 */
+	explicit basic_extents(base_type const& b)
+	  : _base(b)
+	{
+		if (!this->valid()){
+			throw std::length_error("Error in basic_extents::basic_extents() : shape tuple is not a valid permutation: has zero elements.");
+		}
+	}
+
+	/** @brief Move constructs basic_extents from a one-dimensional container
+	 *
+	 * @code auto ex = basic_extents<unsigned>(  std::vector<unsigned>(3u,3u) );
+	 *
+	 * @note checks if size > 1 and all elements > 0
+	 *
+	 * @param b one-dimensional container of type std::vector<int_type>
+	 */
+	explicit basic_extents(base_type && b)
+	  : _base(std::move(b))
+	{
+		if (!this->valid()){
+			throw std::length_error("Error in basic_extents::basic_extents() : shape tuple is not a valid permutation: has zero elements.");
+		}
+	}
+
+	/** @brief Constructs basic_extents from an initializer list
+	 *
+	 * @code auto ex = basic_extents<unsigned>{3,2,4};
+	 *
+	 * @note checks if size > 1 and all elements > 0
+	 *
+	 * @param l one-dimensional list of type std::initializer<int_type>
+	 */
+	basic_extents(std::initializer_list<value_type> l)
+	  : basic_extents( base_type(std::move(l)) )
+	{
+	}
+
+	/** @brief Constructs basic_extents from a range specified by two iterators
+	 *
+	 * @code auto ex = basic_extents<unsigned>(a.begin(), a.end());
+	 *
+	 * @note checks if size > 1 and all elements > 0
+	 *
+	 * @param first iterator pointing to the first element
+	 * @param last iterator pointing to the next position after the last element
+	 */
+	basic_extents(const_iterator first, const_iterator last)
+	  : basic_extents ( base_type( first,last ) )
+	{
+	}
+
+	/** @brief Copy constructs basic_extents */
+	basic_extents(basic_extents const& l )
+	  : _base(l._base)
+	{
+	}
+
+	/** @brief Move constructs basic_extents */
+	basic_extents(basic_extents && l ) noexcept
+	  : _base(std::move(l._base))
+	{
+	}
+
+	~basic_extents() = default;
+
+	basic_extents& operator=(basic_extents other) noexcept
+	{
+		swap (*this, other);
+		return *this;
+	}
+
+	friend void swap(basic_extents& lhs, basic_extents& rhs) {
+		std::swap(lhs._base   , rhs._base   );
+	}
+
+
+
+	/** @brief Returns true if this has a scalar shape
+	 *
+	 * @returns true if (1,1,[1,...,1])
+	*/
+	bool is_scalar() const
+	{
+		return
+		    _base.size() != 0 &&
+		    std::all_of(_base.begin(), _base.end(),
+		                [](const_reference a){ return a == 1;});
+	}
+
+	/** @brief Returns true if this has a vector shape
+	 *
+	 * @returns true if (1,n,[1,...,1]) or (n,1,[1,...,1]) with n > 1
+	*/
+	bool is_vector() const
+	{
+		if(_base.size() == 0){
+			return false;
+		}
+
+		if(_base.size() == 1){
+			return _base.at(0) > 1;
+		}
+
+		auto greater_one = [](const_reference a){ return a >  1;};
+		auto equal_one   = [](const_reference a){ return a == 1;};
+
+		return
+		    std::any_of(_base.begin(),   _base.begin()+2, greater_one) &&
+		    std::any_of(_base.begin(),   _base.begin()+2, equal_one  ) &&
+		    std::all_of(_base.begin()+2, _base.end(),     equal_one);
+	}
+
+	/** @brief Returns true if this has a matrix shape
+	 *
+	 * @returns true if (m,n,[1,...,1]) with m > 1 and n > 1
+	*/
+	bool is_matrix() const
+	{
+		if(_base.size() < 2){
+			return false;
+		}
+
+		auto greater_one = [](const_reference a){ return a >  1;};
+		auto equal_one   = [](const_reference a){ return a == 1;};
+
+		return
+		    std::all_of(_base.begin(),   _base.begin()+2, greater_one) &&
+		    std::all_of(_base.begin()+2, _base.end(),     equal_one  );
+	}
+
+	/** @brief Returns true if this is has a tensor shape
+	 *
+	 * @returns true if !empty() && !is_scalar() && !is_vector() && !is_matrix()
+	*/
+	bool is_tensor() const
+	{
+		if(_base.size() < 3){
+			return false;
+		}
+
+		auto greater_one = [](const_reference a){ return a > 1;};
+
+		return std::any_of(_base.begin()+2, _base.end(), greater_one);
+	}
+
+	const_pointer data() const
+	{
+		return this->_base.data();
+	}
+
+	const_reference operator[] (size_type p) const
+	{
+		return this->_base[p];
+	}
+
+	const_reference at (size_type p) const
+	{
+		return this->_base.at(p);
+	}
+
+	reference operator[] (size_type p)
+	{
+		return this->_base[p];
+	}
+
+	reference at (size_type p)
+	{
+		return this->_base.at(p);
+	}
+
+
+	bool empty() const
+	{
+		return this->_base.empty();
+	}
+
+	size_type size() const
+	{
+		return this->_base.size();
+	}
+
+	/** @brief Returns true if size > 1 and all elements > 0 */
+	bool valid() const
+	{
+		return
+		    this->size() > 1 &&
+		    std::none_of(_base.begin(), _base.end(),
+		                 [](const_reference a){ return a == value_type(0); });
+	}
+
+	/** @brief Returns the number of elements a tensor holds with this */
+	size_type product() const
+	{
+		if(_base.empty()){
+			return 0;
+		}
+
+		return std::accumulate(_base.begin(), _base.end(), 1ul, std::multiplies<>());
+
+	}
+
+
+	/** @brief Eliminates singleton dimensions when size > 2
+	 *
+	 * squeeze {  1,1} -> {  1,1}
+	 * squeeze {  2,1} -> {  2,1}
+	 * squeeze {  1,2} -> {  1,2}
+	 *
+	 * squeeze {1,2,3} -> {  2,3}
+	 * squeeze {2,1,3} -> {  2,3}
+	 * squeeze {1,3,1} -> {  3,1}
+	 *
+	*/
+	basic_extents squeeze() const
+	{
+		if(this->size() <= 2){
+			return *this;
+		}
+
+		auto new_extent = basic_extents{};
+		auto insert_iter = std::back_insert_iterator<typename basic_extents::base_type>(new_extent._base);
+		std::remove_copy(this->_base.begin(), this->_base.end(), insert_iter ,value_type{1});
+		return new_extent;
+
+	}
+
+	void clear()
+	{
+		this->_base.clear();
+	}
+
+	bool operator == (basic_extents const& b) const
+	{
+		return _base == b._base;
+	}
+
+	bool operator != (basic_extents const& b) const
+	{
+		return !( _base == b._base );
+	}
+
+	const_iterator
+	begin() const
+	{
+		return _base.begin();
+	}
+
+	const_iterator
+	end() const
+	{
+		return _base.end();
+	}
+
+	base_type const& base() const { return _base; }
+
+private:
+
+	base_type _base;
+
+};
+
+using shape = basic_extents<std::size_t>;
+
+} // namespace ublas
+} // namespace numeric
+} // namespace boost
+
+#endif