boost.cxx 0.0.2 → 1.90.1

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

@@ -0,0 +1,244 @@
+//
+//  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_OPERATORS_ARITHMETIC_HPP
+#define BOOST_UBLAS_TENSOR_OPERATORS_ARITHMETIC_HPP
+
+#include "expression.hpp"
+#include "expression_evaluation.hpp"
+#include "multi_index_utility.hpp"
+#include "functions.hpp"
+
+#include <type_traits>
+#include <functional>
+#include <algorithm>
+
+namespace boost{
+namespace numeric{
+namespace ublas {
+
+
+template<class element_type, class storage_format, class storage_type>
+class tensor;
+
+template<class E>
+class matrix_expression;
+
+
+template<class E>
+class vector_expression;
+
+}
+}
+}
+
+#define FIRST_ORDER_OPERATOR_RIGHT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \
+template<class T, class L, class R> \
+auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L <T,L> const& lhs, boost::numeric::ublas:: EXPR_TYPE_R <R> const& rhs) { \
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), \
+	  [](auto const& l, auto const& r){ return l OP r; }); \
+} \
+
+FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , vector_expression)
+FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , vector_expression)
+FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , vector_expression)
+FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , vector_expression)
+
+FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , matrix_expression)
+FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , matrix_expression)
+FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , matrix_expression)
+FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , matrix_expression)
+
+
+#define FIRST_ORDER_OPERATOR_LEFT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \
+template<class T, class L, class R> \
+auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L <L> const& lhs, boost::numeric::ublas:: EXPR_TYPE_R <T,R> const& rhs) { \
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), \
+	  [](auto const& l, auto const& r){ return l OP r; }); \
+} \
+
+FIRST_ORDER_OPERATOR_LEFT (*, vector_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (+, vector_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (-, vector_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (/, vector_expression, detail:: tensor_expression)
+
+FIRST_ORDER_OPERATOR_LEFT (*, matrix_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (+, matrix_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (-, matrix_expression, detail:: tensor_expression)
+FIRST_ORDER_OPERATOR_LEFT (/, matrix_expression, detail:: tensor_expression)
+
+
+
+
+template<class T, class L, class R>
+auto operator+( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l + r; });
+}
+template<class T, class L, class R>
+auto operator-( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l - r; });
+//	return boost::numeric::ublas::detail::make_lambda<T>([&lhs,&rhs](std::size_t i){ return lhs(i) - rhs(i);});
+}
+template<class T, class L, class R>
+auto operator*( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l * r; });
+}
+template<class T, class L, class R>
+auto operator/( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l / r; });
+}
+
+
+// Overloaded Arithmetic Operators with Scalars
+template<class T, class R>
+auto operator+(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs + r; });
+	//return boost::numeric::ublas::detail::make_lambda<T>( [&lhs,&rhs](std::size_t i) {return lhs + rhs(i); } );
+}
+template<class T, class R>
+auto operator-(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs - r; });
+}
+template<class T, class R>
+auto operator*(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs * r; });
+}
+template<class T, class R>
+auto operator/(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs / r; });
+}
+
+
+template<class T, class L>
+auto operator+(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l + rhs; } );
+}
+template<class T, class L>
+auto operator-(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l - rhs; } );
+}
+template<class T, class L>
+auto operator*(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l * rhs; } );
+}
+template<class T, class L>
+auto operator/(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l / rhs; } );
+}
+
+
+
+template<class T, class D>
+auto& operator += (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
+	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l+=r; } );
+	return lhs;
+}
+
+template<class T, class D>
+auto& operator -= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
+	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l-=r; } );
+	return lhs;
+}
+
+template<class T, class D>
+auto& operator *= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
+	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l*=r; } );
+	return lhs;
+}
+
+template<class T, class D>
+auto& operator /= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
+	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l/=r; } );
+	return lhs;
+}
+
+
+
+
+template<class E, class F, class A>
+auto& operator += (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
+	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l+=r; } );
+	return lhs;
+}
+
+template<class E, class F, class A>
+auto& operator -= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
+	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l-=r; } );
+	return lhs;
+}
+
+template<class E, class F, class A>
+auto& operator *= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
+	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l*=r; } );
+	return lhs;
+}
+
+template<class E, class F, class A>
+auto& operator /= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
+	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l/=r; } );
+	return lhs;
+}
+
+
+
+
+
+
+template<class T, class D>
+auto const& operator +(const boost::numeric::ublas::detail::tensor_expression<T,D>& lhs) {
+	return lhs;
+}
+
+template<class T, class D>
+auto operator -(boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs) {
+	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [] (auto const& l) { return -l; } );
+}
+
+
+
+
+
+/** @brief Performs a tensor contraction, not an elementwise multiplication
+	*
+*/
+
+template<class tensor_type_left, class tuple_type_left, class tensor_type_right, class tuple_type_right>
+auto operator*(
+		std::pair< tensor_type_left  const&, tuple_type_left  > lhs,
+		std::pair< tensor_type_right const&, tuple_type_right > rhs)
+{
+
+	using namespace boost::numeric::ublas;
+
+	auto const& tensor_left  = lhs.first;
+	auto const& tensor_right = rhs.first;
+
+	auto multi_index_left = lhs.second;
+	auto multi_index_right = rhs.second;
+
+	static constexpr auto num_equal_ind = number_equal_indexes<tuple_type_left, tuple_type_right>::value;
+
+	if constexpr ( num_equal_ind == 0  ){
+		return tensor_left * tensor_right;
+	}
+	else if constexpr ( num_equal_ind==std::tuple_size<tuple_type_left>::value && std::is_same<tuple_type_left, tuple_type_right>::value ){
+
+		return boost::numeric::ublas::inner_prod( tensor_left, tensor_right );
+	}
+	else {
+		auto array_index_pairs = index_position_pairs(multi_index_left,multi_index_right);
+		auto index_pairs = array_to_vector(  array_index_pairs  );
+		return boost::numeric::ublas::prod( tensor_left, tensor_right, index_pairs.first, index_pairs.second );
+	}
+
+}
+
+#endif

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

@@ -0,0 +1,175 @@
+//
+//  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_OPERATORS_COMPARISON_HPP
+#define BOOST_UBLAS_TENSOR_OPERATORS_COMPARISON_HPP
+
+#include <boost/numeric/ublas/tensor/expression.hpp>
+#include <boost/numeric/ublas/tensor/expression_evaluation.hpp>
+#include <type_traits>
+#include <functional>
+
+namespace boost::numeric::ublas {
+template<class element_type, class storage_format, class storage_type>
+class tensor;
+}
+
+namespace boost::numeric::ublas::detail {
+
+template<class T, class F, class A, class BinaryPred>
+bool compare(tensor<T,F,A> const& lhs, tensor<T,F,A> const& rhs, BinaryPred pred)
+{
+
+	if(lhs.extents() != rhs.extents()){
+		if constexpr(!std::is_same<BinaryPred,std::equal_to<>>::value && !std::is_same<BinaryPred,std::not_equal_to<>>::value)
+			throw std::runtime_error("Error in boost::numeric::ublas::detail::compare: cannot compare tensors with different shapes.");
+		else
+			return false;
+	}
+
+	if constexpr(std::is_same<BinaryPred,std::greater<>>::value || std::is_same<BinaryPred,std::less<>>::value)
+		if(lhs.empty())
+			return false;
+
+	for(auto i = 0u; i < lhs.size(); ++i)
+		if(!pred(lhs(i), rhs(i)))
+			return false;
+	return true;
+}
+
+template<class T, class F, class A, class UnaryPred>
+bool compare(tensor<T,F,A> const& rhs, UnaryPred pred)
+{
+	for(auto i = 0u; i < rhs.size(); ++i)
+		if(!pred(rhs(i)))
+			return false;
+	return true;
+}
+
+
+template<class T, class L, class R, class BinaryPred>
+bool compare(tensor_expression<T,L> const& lhs, tensor_expression<T,R> const& rhs, BinaryPred pred)
+{
+	constexpr bool lhs_is_tensor = std::is_same<T,L>::value;
+	constexpr bool rhs_is_tensor = std::is_same<T,R>::value;
+
+	if constexpr (lhs_is_tensor && rhs_is_tensor)
+		return compare(static_cast<T const&>( lhs ), static_cast<T const&>( rhs ), pred);
+	else if constexpr (lhs_is_tensor && !rhs_is_tensor)
+		return compare(static_cast<T const&>( lhs ), T( rhs ), pred);
+	else if constexpr (!lhs_is_tensor && rhs_is_tensor)
+		return compare(T( lhs ), static_cast<T const&>( rhs ), pred);
+	else
+		return compare(T( lhs ), T( rhs ), pred);
+
+}
+
+template<class T, class D, class UnaryPred>
+bool compare(tensor_expression<T,D> const& expr, UnaryPred pred)
+{
+	if constexpr (std::is_same<T,D>::value)
+		return compare(static_cast<T const&>( expr ), pred);
+	else
+		return compare(T( expr ), pred);
+}
+
+}
+
+
+template<class T, class L, class R>
+bool operator==( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								 boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::equal_to<>{} );
+}
+template<class T, class L, class R>
+auto operator!=(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::not_equal_to<>{}  );
+}
+template<class T, class L, class R>
+auto operator< ( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								 boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::less<>{} );
+}
+template<class T, class L, class R>
+auto operator<=( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								 boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::less_equal<>{} );
+}
+template<class T, class L, class R>
+auto operator> ( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								 boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::greater<>{} );
+}
+template<class T, class L, class R>
+auto operator>=( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
+								 boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, rhs, std::greater_equal<>{} );
+}
+
+
+
+
+
+template<class T, class D>
+bool operator==( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs == r; } );
+}
+template<class T, class D>
+auto operator!=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs != r; } );
+}
+template<class T, class D>
+auto operator< ( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs <  r; } );
+}
+template<class T, class D>
+auto operator<=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs <= r; } );
+}
+template<class T, class D>
+auto operator> ( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs >  r; } );
+}
+template<class T, class D>
+auto operator>=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
+	return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs >= r; } );
+}
+
+
+
+template<class T, class D>
+bool operator==( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l == rhs; } );
+}
+template<class T, class D>
+auto operator!=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l != rhs; } );
+}
+template<class T, class D>
+auto operator< ( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l <  rhs; } );
+}
+template<class T, class D>
+auto operator<=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l <= rhs; } );
+}
+template<class T, class D>
+auto operator> ( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l >  rhs; } );
+}
+template<class T, class D>
+auto operator>=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
+	return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l >= rhs; } );
+}
+
+
+#endif

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

@@ -0,0 +1,122 @@
+//
+//  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_OSTREAM_HPP
+#define BOOST_UBLAS_TENSOR_OSTREAM_HPP
+
+#include <ostream>
+#include <complex>
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+namespace detail {
+
+template <class value_type>
+void print(std::ostream& out, value_type const& p)
+{
+	out << p << " ";
+}
+
+template <class value_type>
+void print(std::ostream& out, const std::complex<value_type>& p)
+{
+	out << std::real(p) << "+" << std::imag(p) << "i ";
+}
+
+
+template <class size_type, class value_type>
+void print(std::ostream& out, size_type r, const value_type* p, const size_type* w, const size_type* n)
+{
+
+	if(r < 2)
+	{
+		out << "[ ... " << std::endl;
+
+		for(auto row = 0u; row < n[0]; p += w[0], ++row) // iterate over one column
+		{
+			auto p1 = p;
+			for(auto col = 0u; col < n[1]; p1 += w[1], ++col) // iterate over first row
+			{
+				print(out,*p1);
+			}
+			if(row < n[0]-1)
+				out << "; " << std::endl;
+		}
+		out << "]";
+	}
+	else
+	{
+		out << "cat("<< r+1 <<",..." << std::endl;
+		for(auto d = 0u; d < n[r]-1; p += w[r], ++d){
+			print(out, r-1, p, w, n);
+			out << ",..." << std::endl;
+		}
+		print(out, r-1, p, w, n);
+	}
+	if(r>1)
+		out << ")";
+}
+
+////////////////////////////
+
+
+}
+}
+}
+}
+
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+
+template<class T, class F, class A>
+class tensor;
+
+template<class T, class F, class A>
+class matrix;
+
+template<class T, class A>
+class vector;
+
+}
+}
+}
+
+
+template <class V, class F, class A>
+std::ostream& operator << (std::ostream& out, boost::numeric::ublas::tensor<V,F,A> const& t)
+{
+
+	if(t.extents().is_scalar()){
+		out << '[';
+		boost::numeric::ublas::detail::print(out,t[0]);
+		out << ']';
+	}
+	else if(t.extents().is_vector()) {
+		const auto& cat = t.extents().at(0) > t.extents().at(1) ? ';' : ',';
+		out << '[';
+		for(auto i = 0u; i < t.size()-1; ++i){
+			boost::numeric::ublas::detail::print(out,t[i]);
+			out << cat << ' ';
+		}
+		boost::numeric::ublas::detail::print(out,t[t.size()-1]);
+		out << ']';
+	}
+	else{
+		boost::numeric::ublas::detail::print(out, t.rank()-1, t.data(), t.strides().data(), t.extents().data());
+	}
+	return out;
+}
+
+
+#endif

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

@@ -0,0 +1,84 @@
+//
+//  Copyright (c) 2018, 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_STORAGE_TRAITS_HPP_
+#define _BOOST_STORAGE_TRAITS_HPP_
+
+#include <vector>
+#include <array>
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+
+
+template <class A>
+struct storage_traits;
+
+
+template <class V, class A>
+struct storage_traits<std::vector<V,A>>
+{
+	using array_type      = std::vector<V,A>;
+
+	using size_type       = typename array_type::size_type;
+	using difference_type = typename array_type::difference_type;
+	using value_type      = typename array_type::value_type;
+
+	using reference       = typename array_type::reference;
+	using const_reference = typename array_type::const_reference;
+
+	using pointer         = typename array_type::pointer;
+	using const_pointer   = typename array_type::const_pointer;
+
+	using iterator        = typename array_type::iterator;
+	using const_iterator  = typename array_type::const_iterator;
+
+	using reverse_iterator        = typename array_type::reverse_iterator;
+	using const_reverse_iterator  = typename array_type::const_reverse_iterator;
+
+	template<class U>
+	using rebind = std::vector<U, typename std::allocator_traits<A>::template rebind_alloc<U>>;
+};
+
+
+template <class V, std::size_t N>
+struct storage_traits<std::array<V,N>>
+{
+	using array_type      = std::array<V,N>;
+
+	using size_type       = typename array_type::size_type;
+	using difference_type = typename array_type::difference_type;
+	using value_type      = typename array_type::value_type;
+
+	using reference       = typename array_type::reference;
+	using const_reference = typename array_type::const_reference;
+
+	using pointer         = typename array_type::pointer;
+	using const_pointer   = typename array_type::const_pointer;
+
+	using iterator        = typename array_type::iterator;
+	using const_iterator  = typename array_type::const_iterator;
+
+	using reverse_iterator        = typename array_type::reverse_iterator;
+	using const_reverse_iterator  = typename array_type::const_reverse_iterator;
+
+	template<class U>
+	using rebind = std::array<U,N>;
+};
+
+} // ublas
+} // numeric
+} // boost
+
+
+#endif // _BOOST_STORAGE_TRAITS_HPP_