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